nessarandClaude Opus 5.5
4d26e65672
Bundle the planning core at a871f8f (develop after PR #278) as a frozen
fixture and compare it with the current engine on 5,000 seeded random
requests. Outcomes, stable explanations, explanation errors and final-state
snapshots must be strictly deep-equal. Requests cover obligations,
preferences, IF_THEN and TIME_WINDOW rules, earned entitlements, composed
optimization rules, declared days, year boundaries and public holidays.
Refs #280
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
3223 lines
141 KiB
JavaScript
3223 lines
141 KiB
JavaScript
// src/app/services/declared-non-working-days.ts
|
||
import Holidays from "date-holidays";
|
||
|
||
// src/app/services/planning-date.ts
|
||
function planningDateInParis(value) {
|
||
const parts = new Intl.DateTimeFormat("en-GB", {
|
||
timeZone: "Europe/Paris",
|
||
year: "numeric",
|
||
month: "2-digit",
|
||
day: "2-digit"
|
||
}).formatToParts(value);
|
||
const get = (type) => parts.find((part) => part.type === type)?.value ?? "";
|
||
return `${get("year").padStart(4, "0")}-${get("month")}-${get("day")}`;
|
||
}
|
||
function addPlanningYears(key, years) {
|
||
const date = new Date(`${key}T00:00:00Z`);
|
||
const month = date.getUTCMonth();
|
||
date.setUTCFullYear(date.getUTCFullYear() + years);
|
||
if (date.getUTCMonth() !== month)
|
||
date.setUTCDate(0);
|
||
return date.toISOString().slice(0, 10);
|
||
}
|
||
function isPlanningDate(value) {
|
||
if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value))
|
||
return false;
|
||
const date = new Date(`${value}T00:00:00Z`);
|
||
return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
|
||
}
|
||
|
||
// src/app/services/declared-non-working-days.ts
|
||
var holidaysByYear = new Map;
|
||
function frenchPublicHolidaysForYear(year) {
|
||
let holidays = holidaysByYear.get(year);
|
||
if (!holidays) {
|
||
holidays = new Set(new Holidays("FR", { languages: ["en"] }).getHolidays(year, "en").filter((holiday) => holiday.type === "public").map((holiday) => String(holiday.date).slice(0, 10)));
|
||
holidaysByYear.set(year, holidays);
|
||
}
|
||
return holidays;
|
||
}
|
||
function isWorkingPlanningDate(value) {
|
||
if (!isPlanningDate(value))
|
||
return false;
|
||
const day = new Date(`${value}T00:00:00Z`).getUTCDay();
|
||
return day !== 0 && day !== 6 && !frenchPublicHolidaysForYear(Number(value.slice(0, 4))).has(value);
|
||
}
|
||
function parseDeclaredDays(value) {
|
||
if (!Array.isArray(value))
|
||
throw new Error("Declared non-working days must be a list.");
|
||
const dates = new Set;
|
||
return value.map((item) => {
|
||
if (typeof item !== "object" || item === null)
|
||
throw new Error("Each declared non-working day needs a date and leave type.");
|
||
const { date, type } = item;
|
||
if (!isWorkingPlanningDate(date) || dates.has(date))
|
||
throw new Error("Declared dates must be unique working days outside French public holidays.");
|
||
if (type !== "cp" && type !== "rtt" && type !== "other")
|
||
throw new Error("Declared non-working days must have a CP, RTT, or Other type.");
|
||
dates.add(date);
|
||
return { date, type };
|
||
});
|
||
}
|
||
|
||
// src/app/services/planning-objectives.ts
|
||
var OPTIMIZATION_CATALOG = [
|
||
{
|
||
elements: "leave-balances",
|
||
measure: "unplaced-quantity",
|
||
conditions: ["at-risk"],
|
||
aggregations: ["sum", "count", "maximum"],
|
||
unit: "working-days"
|
||
},
|
||
{
|
||
elements: "public-holiday-weeks",
|
||
measure: "public-holiday-week-value",
|
||
conditions: ["complete"],
|
||
aggregations: ["sum", "count", "maximum"],
|
||
unit: "calendar-days"
|
||
},
|
||
{
|
||
elements: "time-off-periods",
|
||
measure: "non-working-day-gain",
|
||
conditions: [],
|
||
aggregations: ["sum", "count", "maximum"],
|
||
unit: "calendar-days"
|
||
},
|
||
{
|
||
elements: "work-sequences",
|
||
measure: "work-sequence-length",
|
||
conditions: ["internal", "non-empty"],
|
||
aggregations: ["sum", "count", "maximum"],
|
||
unit: "working-days"
|
||
},
|
||
{
|
||
elements: "work-sequences",
|
||
measure: "work-sequence-deficit",
|
||
conditions: ["internal", "non-empty"],
|
||
aggregations: ["sum", "count", "maximum"],
|
||
unit: "working-days"
|
||
},
|
||
{
|
||
elements: "leave-placements",
|
||
measure: "placement-count",
|
||
conditions: ["supporting"],
|
||
aggregations: ["sum", "count", "maximum"],
|
||
unit: "count"
|
||
}
|
||
];
|
||
function validateOptimizationConfiguration(value) {
|
||
const invalid = (message) => ({
|
||
valid: false,
|
||
code: "invalid-optimization-configuration",
|
||
message
|
||
});
|
||
const unsupported = (message) => ({
|
||
valid: false,
|
||
code: "unsupported-optimization-configuration",
|
||
message
|
||
});
|
||
if (!value || typeof value !== "object" || Array.isArray(value))
|
||
return invalid("An optimization configuration must be an object.");
|
||
const config = value;
|
||
const fields = [
|
||
"elements",
|
||
"conditions",
|
||
"measure",
|
||
"aggregation",
|
||
"direction",
|
||
"thresholdDays"
|
||
];
|
||
if (Object.keys(config).some((key) => !fields.includes(key)))
|
||
return unsupported("The optimization configuration contains an unsupported field.");
|
||
if (config["direction"] !== "minimize" && config["direction"] !== "maximize")
|
||
return invalid("The optimization direction must be minimize or maximize.");
|
||
if (!Array.isArray(config["conditions"]) || [...config["conditions"]].some((condition) => typeof condition !== "string") || new Set(config["conditions"]).size !== config["conditions"].length)
|
||
return invalid("Optimization conditions must be a list of distinct conditions.");
|
||
const row = OPTIMIZATION_CATALOG.find((item) => item.elements === config["elements"] && item.measure === config["measure"]);
|
||
if (!row)
|
||
return unsupported("The planning elements and measure are not compatible.");
|
||
const conditions = row.conditions;
|
||
if (config["conditions"].some((condition) => !conditions.includes(condition)))
|
||
return unsupported("A condition is not supported for these planning elements.");
|
||
const aggregations = row.aggregations;
|
||
if (typeof config["aggregation"] !== "string" || !aggregations.includes(config["aggregation"]))
|
||
return unsupported("The aggregation is not supported for this measure.");
|
||
if (config["measure"] === "work-sequence-deficit") {
|
||
if (!Number.isSafeInteger(config["thresholdDays"]) || Number(config["thresholdDays"]) <= 0)
|
||
return invalid("The deficit threshold must be a positive integer in working days.");
|
||
} else if ("thresholdDays" in config)
|
||
return unsupported("Only the work-sequence deficit accepts a working-day threshold.");
|
||
return { valid: true, configuration: value };
|
||
}
|
||
var OPTIMIZATION_PRESETS = {
|
||
unplacedAtRisk: {
|
||
elements: "leave-balances",
|
||
conditions: ["at-risk"],
|
||
measure: "unplaced-quantity",
|
||
aggregation: "sum",
|
||
direction: "minimize"
|
||
},
|
||
holidayWeekValue: {
|
||
elements: "public-holiday-weeks",
|
||
conditions: ["complete"],
|
||
measure: "public-holiday-week-value",
|
||
aggregation: "sum",
|
||
direction: "maximize"
|
||
},
|
||
nonWorkingDayGain: {
|
||
elements: "time-off-periods",
|
||
conditions: [],
|
||
measure: "non-working-day-gain",
|
||
aggregation: "sum",
|
||
direction: "maximize"
|
||
},
|
||
longestWorkSequence: {
|
||
elements: "work-sequences",
|
||
conditions: [],
|
||
measure: "work-sequence-length",
|
||
aggregation: "maximum",
|
||
direction: "minimize"
|
||
},
|
||
shortSequenceDeficit: {
|
||
elements: "work-sequences",
|
||
conditions: ["internal", "non-empty"],
|
||
measure: "work-sequence-deficit",
|
||
thresholdDays: 5,
|
||
aggregation: "sum",
|
||
direction: "minimize"
|
||
},
|
||
supportingPlacements: {
|
||
elements: "leave-placements",
|
||
conditions: ["supporting"],
|
||
measure: "placement-count",
|
||
aggregation: "count",
|
||
direction: "minimize"
|
||
}
|
||
};
|
||
var nonWorkingDateCounts = new WeakMap;
|
||
function evaluateOptimization(configuration, observations) {
|
||
const validation = validateOptimizationConfiguration(configuration);
|
||
if (!validation.valid)
|
||
throw new Error(`${validation.code}: ${validation.message}`);
|
||
const selected = (condition) => configuration.conditions.includes(condition);
|
||
let values;
|
||
switch (configuration.elements) {
|
||
case "leave-balances":
|
||
values = observations.leaveBalances.filter((balance) => !selected("at-risk") || balance.atRisk).map((balance) => balance.unplacedQuantity);
|
||
break;
|
||
case "public-holiday-weeks":
|
||
values = observations.publicHolidayWeeks.filter((week) => !selected("complete") || week.complete).map((week) => week.value);
|
||
break;
|
||
case "time-off-periods":
|
||
values = observations.timeOffPeriods.map(({ nonWorkingDates }) => {
|
||
const cached = nonWorkingDateCounts.get(nonWorkingDates);
|
||
if (cached !== undefined)
|
||
return cached;
|
||
const count = new Set(nonWorkingDates).size;
|
||
if (Object.isFrozen(nonWorkingDates))
|
||
nonWorkingDateCounts.set(nonWorkingDates, count);
|
||
return count;
|
||
});
|
||
break;
|
||
case "work-sequences":
|
||
values = observations.workSequences.filter((sequence) => (!selected("internal") || sequence.internal) && (!selected("non-empty") || sequence.length > 0)).map((sequence) => configuration.measure === "work-sequence-deficit" ? sequence.length > 0 ? Math.max(0, configuration.thresholdDays - sequence.length) : 0 : sequence.length);
|
||
break;
|
||
case "leave-placements":
|
||
values = observations.leavePlacements.filter((placement) => !selected("supporting") || placement.supporting).map(() => 1);
|
||
}
|
||
switch (configuration.aggregation) {
|
||
case "count":
|
||
return values.length;
|
||
case "sum":
|
||
return values.reduce((total, value) => total + value, 0);
|
||
case "maximum":
|
||
return values.reduce((maximum, value) => Math.max(maximum, value), 0);
|
||
}
|
||
}
|
||
function compareObjectiveValues(direction, left, right) {
|
||
if (left === right)
|
||
return 0;
|
||
const difference = typeof left === "number" && typeof right === "number" ? left - right : left < right ? -1 : left > right ? 1 : 0;
|
||
return direction === "minimize" ? difference : -difference;
|
||
}
|
||
function firstDifferentObjective(left, right) {
|
||
return left.findIndex((objective, index) => objective.value !== right[index]?.value);
|
||
}
|
||
function compareObjectiveLists(left, right) {
|
||
const index = firstDifferentObjective(left, right);
|
||
return index < 0 ? 0 : compareObjectiveValues(left[index].direction, left[index].value, right[index].value);
|
||
}
|
||
|
||
// src/app/services/leave-planner.core.ts
|
||
var obligationRequirementCache = new WeakMap;
|
||
var occurrenceCache = new WeakMap;
|
||
var calendarPatternCache = new WeakMap;
|
||
var preferencePatternCache = new WeakMap;
|
||
var declaredWindowCache = new WeakMap;
|
||
var calendarObservationCache = new WeakMap;
|
||
var calendarPeriodCache = new WeakMap;
|
||
function now() {
|
||
return typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
|
||
}
|
||
function observeCallback(context, callback) {
|
||
const started = now();
|
||
try {
|
||
callback();
|
||
} finally {
|
||
context.observerTime += now() - started;
|
||
}
|
||
}
|
||
|
||
class DeadlineReached extends Error {
|
||
}
|
||
|
||
class UserCancelled extends Error {
|
||
}
|
||
var DAY_MS = 86400000;
|
||
var OBLIGATION_SOLUTION_LIMIT = 4096;
|
||
var EXACT_OBLIGATION_BRANCH_LIMIT = 1e4;
|
||
var WINDOW_OBLIGATION_PREVIEW_LIMIT = 8;
|
||
var VALID_TYPES = new Set(["cp", "rtt", "other"]);
|
||
var VALID_SELECTORS = new Set(["cp", "rtt", "other", "any"]);
|
||
var VALID_MODES = new Set(["before", "after", "around", "auto"]);
|
||
function dateKey(value) {
|
||
if (typeof value === "string") {
|
||
const dateOnly = value.match(/^(\d{4}-\d{2}-\d{2})(?:$|\s|T)/)?.[1];
|
||
if (dateOnly)
|
||
return isPlanningDate(dateOnly) ? dateOnly : null;
|
||
const parsed = new Date(value);
|
||
return Number.isNaN(parsed.getTime()) ? null : planningDateInParis(parsed);
|
||
}
|
||
if (value instanceof Date && !Number.isNaN(value.getTime()))
|
||
return planningDateInParis(value);
|
||
return null;
|
||
}
|
||
function runtimeRequest(value, calculationDate) {
|
||
const source = recordValue(value) ?? {};
|
||
return {
|
||
calculationDate: calculationDate ?? (isPlanningDate(source.calculationDate) ? source.calculationDate : planningDateInParis(new Date)),
|
||
horizon: source.horizon,
|
||
balances: source.balances,
|
||
declaredDays: source.declaredDays,
|
||
rules: source.rules,
|
||
identities: source.identities,
|
||
labels: source.labels,
|
||
deadlineMs: source.deadlineMs,
|
||
progress: source.progress
|
||
};
|
||
}
|
||
function recordValue(value) {
|
||
return typeof value === "object" && value !== null ? value : undefined;
|
||
}
|
||
function utcDate(key) {
|
||
return new Date(`${key}T00:00:00Z`);
|
||
}
|
||
function addDays(key, days) {
|
||
return new Date(utcDate(key).getTime() + days * DAY_MS).toISOString().slice(0, 10);
|
||
}
|
||
function compareDate(a, b) {
|
||
return a < b ? -1 : a > b ? 1 : 0;
|
||
}
|
||
function compareText(a, b) {
|
||
return a < b ? -1 : a > b ? 1 : 0;
|
||
}
|
||
function dateRange(start, endExclusive) {
|
||
const result = [];
|
||
for (let date = start;compareDate(date, endExclusive) < 0; date = addDays(date, 1))
|
||
result.push(date);
|
||
return result;
|
||
}
|
||
function defaultHorizon(start) {
|
||
return { start, end: addPlanningYears(start, 1) };
|
||
}
|
||
function holidaySet(horizon) {
|
||
const first = Number(addDays(horizon.start, -400).slice(0, 4));
|
||
const last = Number(addDays(horizon.end, 400).slice(0, 4));
|
||
const result = new Set;
|
||
for (let year = first;year <= last; year++) {
|
||
for (const holiday of frenchPublicHolidaysForYear(year))
|
||
result.add(holiday);
|
||
}
|
||
return result;
|
||
}
|
||
function isWeekend(key) {
|
||
const day = utcDate(key).getUTCDay();
|
||
return day === 0 || day === 6;
|
||
}
|
||
function isWorking(key, holidays) {
|
||
return !isWeekend(key) && !holidays.has(key);
|
||
}
|
||
function holidayWeekCandidates(context) {
|
||
const candidates = new Map;
|
||
const inHorizon = (date) => date >= context.horizon.start && date < context.horizon.end;
|
||
for (const holiday of [...context.holidays].sort(compareDate)) {
|
||
const weekday = utcDate(holiday).getUTCDay();
|
||
if (weekday < 1 || weekday > 5)
|
||
continue;
|
||
const start = addDays(holiday, 1 - weekday);
|
||
const weekdays = dateRange(start, addDays(start, 5));
|
||
const dates = weekdays.filter((date) => isWorking(date, context.holidays));
|
||
if (!dates.length || !dates.some(inHorizon) || !inHorizon(holiday) && !dates.some((date) => context.declaredDates.has(date)) || dates.some((date) => !inHorizon(date) && !context.declaredDates.has(date)))
|
||
continue;
|
||
const value = weekdays.reduce((sum, date, index) => sum + (context.holidays.has(date) ? Math.min(index + 1, 5 - index) : 0), 0);
|
||
candidates.set(start, { start, dates, value });
|
||
}
|
||
return [...candidates.values()].sort((a, b) => b.value - a.value || compareDate(a.start, b.start));
|
||
}
|
||
function reason(code, message, ruleIds) {
|
||
return ruleIds?.length ? { code, message, ruleIds } : { code, message };
|
||
}
|
||
function cloneState(state, placements) {
|
||
return {
|
||
balances: state.balances.map((balance) => ({ ...balance })),
|
||
placements: placements ?? new Map([...state.placements.entries()].map(([date, placement]) => [
|
||
date,
|
||
{
|
||
...placement,
|
||
ruleIds: new Set(placement.ruleIds)
|
||
}
|
||
])),
|
||
earnedActivations: state.earnedActivations.map((activation) => ({
|
||
...activation,
|
||
dates: [...activation.dates]
|
||
}))
|
||
};
|
||
}
|
||
function planningStateSnapshot(state, context) {
|
||
return {
|
||
calculationDate: context.request.calculationDate,
|
||
horizon: context.horizon,
|
||
...context.declaredDays.length ? { declaredDays: context.declaredDays } : {},
|
||
balances: state.balances.map((balance) => ({ ...balance })),
|
||
placements: [...state.placements.values()].sort((a, b) => compareDate(a.date, b.date) || compareText(a.balanceId, b.balanceId)).map((placement) => ({
|
||
...placement,
|
||
ruleIds: [...placement.ruleIds].sort()
|
||
})),
|
||
earnedActivations: state.earnedActivations.map((activation) => ({
|
||
...activation,
|
||
dates: [...activation.dates]
|
||
}))
|
||
};
|
||
}
|
||
function normalizeType(value) {
|
||
const normalized = String(value ?? "").toLowerCase();
|
||
return VALID_TYPES.has(normalized) ? normalized : null;
|
||
}
|
||
function normalizeSelector(value) {
|
||
const normalized = String(value ?? "").toLowerCase();
|
||
return VALID_SELECTORS.has(normalized) ? normalized : null;
|
||
}
|
||
function normalizeForce(value) {
|
||
if (value === undefined || value === "")
|
||
return "preference";
|
||
const normalized = String(value).toLowerCase();
|
||
if (normalized === "obligation" || normalized === "preference")
|
||
return normalized;
|
||
return null;
|
||
}
|
||
function normalizeRuleType(value) {
|
||
const normalized = String(value ?? "").toLowerCase();
|
||
return normalized === "time_window" || normalized === "if_then" || normalized === "optimization" ? normalized : null;
|
||
}
|
||
function normalizeMode(value) {
|
||
const normalized = String(value ?? "").toLowerCase();
|
||
return VALID_MODES.has(normalized) ? normalized : null;
|
||
}
|
||
function compareDateLists(a, b) {
|
||
for (let index = 0;index < Math.min(a.length, b.length); index++) {
|
||
const compared = compareDate(a[index], b[index]);
|
||
if (compared)
|
||
return compared;
|
||
}
|
||
return a.length - b.length;
|
||
}
|
||
function asInteger(value) {
|
||
return typeof value === "number" && Number.isInteger(value) ? value : null;
|
||
}
|
||
function normalizeBalances(request, horizon) {
|
||
const rawInput = request.balances;
|
||
const reasons = [];
|
||
if (!Array.isArray(rawInput)) {
|
||
return {
|
||
balances: [],
|
||
reasons: [reason("balances", "Leave balances must be an array.")]
|
||
};
|
||
}
|
||
const raw = rawInput;
|
||
const ids = new Set;
|
||
const balances = [];
|
||
for (const input of raw) {
|
||
const value = recordValue(input);
|
||
const id = typeof value?.id === "string" ? value.id : "";
|
||
const type = normalizeType(value?.type);
|
||
const quantity = asInteger(value?.quantity);
|
||
const rawAvailableFrom = value?.availableFrom;
|
||
const availableFrom = dateKey(rawAvailableFrom) ?? horizon.start;
|
||
const expiryDate = dateKey(value?.expiryDate);
|
||
if (!id)
|
||
reasons.push(reason("balance-id", "Each leave balance needs a stable identity."));
|
||
else if (ids.has(id))
|
||
reasons.push(reason("duplicate-balance-id", `Leave balance id "${id}" is duplicated.`));
|
||
else
|
||
ids.add(id);
|
||
if (!type)
|
||
reasons.push(reason("balance-type", `Leave balance "${id}" has an invalid leave type.`));
|
||
if (quantity === null || quantity < 0) {
|
||
reasons.push(reason("balance-quantity", `Leave balance "${id}" needs a non-negative integer quantity.`));
|
||
}
|
||
if (!expiryDate)
|
||
reasons.push(reason("balance-expiry", `Leave balance "${id}" needs a valid expiry date.`));
|
||
if (rawAvailableFrom !== undefined && !dateKey(rawAvailableFrom))
|
||
reasons.push(reason("balance-availability", `Leave balance "${id}" needs a valid availability date.`));
|
||
if (expiryDate && compareDate(availableFrom, expiryDate) > 0 && rawAvailableFrom !== undefined) {
|
||
reasons.push(reason("balance-dates", `Leave balance "${id}" must be available on or before expiry.`));
|
||
}
|
||
if (type && quantity !== null && quantity >= 0 && expiryDate) {
|
||
balances.push({
|
||
id,
|
||
type,
|
||
quantity,
|
||
availableFrom,
|
||
expiryDate,
|
||
earned: false
|
||
});
|
||
}
|
||
}
|
||
return { balances, reasons };
|
||
}
|
||
function normalizeRules(request) {
|
||
const rawInput = request.rules;
|
||
const reasons = [];
|
||
if (!Array.isArray(rawInput)) {
|
||
return { rules: [], reasons: [reason("rules", "Planning rules must be an array.")] };
|
||
}
|
||
const raw = rawInput;
|
||
const ids = new Set;
|
||
const rules = [];
|
||
for (const input of raw) {
|
||
const value = recordValue(input);
|
||
if (value?.enabled === false)
|
||
continue;
|
||
const id = typeof value?.id === "string" ? value.id : "";
|
||
const type = normalizeRuleType(value?.type);
|
||
const forceValue = normalizeForce(value?.force);
|
||
const force = forceValue ?? "preference";
|
||
if (!id)
|
||
reasons.push(reason("rule-id", "Each planning rule needs a stable identity."));
|
||
else if (ids.has(id))
|
||
reasons.push(reason("duplicate-rule-id", `Planning rule id "${id}" is duplicated.`));
|
||
else
|
||
ids.add(id);
|
||
if (!forceValue)
|
||
reasons.push(reason("rule-force", `Planning rule "${id}" has an invalid force.`));
|
||
if (!type) {
|
||
reasons.push(reason("rule-type", `Planning rule "${id}" has an unsupported type.`));
|
||
continue;
|
||
}
|
||
if (type === "optimization") {
|
||
const validated = validateOptimizationConfiguration(value?.configuration);
|
||
if (forceValue !== "preference")
|
||
reasons.push(reason("rule-force", "Optimization rules support preference mode only.", [id]));
|
||
if (!validated.valid) {
|
||
reasons.push(reason(validated.code, validated.message, [id]));
|
||
continue;
|
||
}
|
||
rules.push({
|
||
id,
|
||
name: typeof value?.name === "string" ? value.name : id,
|
||
type,
|
||
enabled: true,
|
||
force: "preference",
|
||
configuration: structuredClone(validated.configuration)
|
||
});
|
||
continue;
|
||
}
|
||
const placeDays = asInteger(value?.placeDays);
|
||
const placeType = normalizeSelector(value?.placeType);
|
||
if (placeDays === null || placeDays < 0) {
|
||
reasons.push(reason("rule-quantity", `Planning rule "${id}" needs a non-negative integer quantity.`));
|
||
continue;
|
||
}
|
||
if (!placeType)
|
||
reasons.push(reason("rule-selector", `Planning rule "${id}" has an invalid leave selector.`));
|
||
const base = {
|
||
id,
|
||
name: typeof value?.name === "string" ? value.name : id,
|
||
type,
|
||
enabled: value?.enabled !== false,
|
||
force,
|
||
placeDays,
|
||
placeType: placeType ?? "any"
|
||
};
|
||
if (type === "time_window") {
|
||
const startDate = dateKey(value?.startDate);
|
||
const endDate = dateKey(value?.endDate);
|
||
if (!startDate || !endDate || compareDate(startDate, endDate) > 0) {
|
||
reasons.push(reason("rule-window", `TIME_WINDOW rule "${id}" needs an inclusive, ordered date window.`));
|
||
continue;
|
||
}
|
||
rules.push({ ...base, startDate, endDate, type: "time_window" });
|
||
continue;
|
||
}
|
||
const dayOfWeek = asInteger(value?.dayOfWeek);
|
||
const mode = normalizeMode(value?.placement);
|
||
const rewardDays = asInteger(value?.rewardDays);
|
||
const rawRewardType = value?.rewardType;
|
||
const rewardType = normalizeType(rawRewardType);
|
||
if (dayOfWeek === null || dayOfWeek < 0 || dayOfWeek > 6) {
|
||
reasons.push(reason("rule-weekday", `IF_THEN rule "${id}" needs a weekday from 0 to 6.`));
|
||
}
|
||
if (!mode)
|
||
reasons.push(reason("rule-mode", `IF_THEN rule "${id}" has an unsupported placement mode.`));
|
||
if (rewardDays === null || rewardDays < 0) {
|
||
reasons.push(reason("earned-quantity", `IF_THEN rule "${id}" needs a non-negative earned quantity.`));
|
||
}
|
||
if ((rewardDays ?? 0) > 0 && !rewardType) {
|
||
reasons.push(reason("earned-type", `IF_THEN rule "${id}" needs CP, RTT, or Other as its earned type.`));
|
||
} else if (rawRewardType !== undefined && !rewardType) {
|
||
reasons.push(reason("earned-type", `IF_THEN rule "${id}" needs CP, RTT, or Other as its earned type.`));
|
||
}
|
||
if (placeType && mode && dayOfWeek !== null && rewardDays !== null && (rewardDays === 0 ? rawRewardType === undefined || rewardType : rewardType)) {
|
||
rules.push({
|
||
...base,
|
||
type: "if_then",
|
||
dayOfWeek,
|
||
placement: mode,
|
||
rewardDays,
|
||
rewardType: rewardType ?? undefined
|
||
});
|
||
}
|
||
}
|
||
return { rules, reasons };
|
||
}
|
||
function normalizeRequest(request) {
|
||
const source = runtimeRequest(request);
|
||
const rawHorizon = recordValue(source.horizon);
|
||
const fallbackHorizon = defaultHorizon(source.calculationDate);
|
||
const start = dateKey(rawHorizon?.start) ?? fallbackHorizon.start;
|
||
const end = dateKey(rawHorizon?.end) ?? fallbackHorizon.end;
|
||
const reasons = [];
|
||
if (!rawHorizon) {
|
||
reasons.push(reason("horizon", "The planning horizon is required."));
|
||
} else if (!dateKey(rawHorizon.start)) {
|
||
reasons.push(reason("horizon-start", "The planning horizon start must be a valid calendar date."));
|
||
}
|
||
if (rawHorizon && !dateKey(rawHorizon.end)) {
|
||
reasons.push(reason("horizon-end", "The planning horizon end must be a valid calendar date."));
|
||
}
|
||
if (rawHorizon && compareDate(start, end) >= 0) {
|
||
reasons.push(reason("horizon-order", "The planning horizon must have start before end."));
|
||
}
|
||
const configuredDeadline = source.deadlineMs;
|
||
if (configuredDeadline !== undefined && (typeof configuredDeadline !== "number" || !Number.isFinite(configuredDeadline) || configuredDeadline < 0)) {
|
||
reasons.push(reason("deadline", "The planning deadline must be a finite non-negative number."));
|
||
}
|
||
let declaredDays = [];
|
||
try {
|
||
declaredDays = parseDeclaredDays(source.declaredDays === undefined ? [] : source.declaredDays);
|
||
} catch (error) {
|
||
reasons.push(reason("declared-days", error instanceof Error ? error.message : String(error)));
|
||
}
|
||
const balanceResult = normalizeBalances(source, { start, end });
|
||
const ruleResult = normalizeRules(source);
|
||
reasons.push(...balanceResult.reasons, ...ruleResult.reasons);
|
||
return {
|
||
horizon: reasons.some((item) => item.code === "horizon" || item.code.startsWith("horizon-")) ? undefined : { start, end },
|
||
balances: balanceResult.balances,
|
||
declaredDays,
|
||
rules: ruleResult.rules,
|
||
reasons
|
||
};
|
||
}
|
||
function invalidInputFor(request) {
|
||
const normalized = normalizeRequest(request);
|
||
if (!normalized.reasons.length)
|
||
return;
|
||
return {
|
||
kind: "InvalidInput",
|
||
reasons: normalized.reasons
|
||
};
|
||
}
|
||
function futurePreferenceProtection(rules, startIndex, context) {
|
||
const protectedTypes = new Map;
|
||
context.preferenceDemandByDate = new Map;
|
||
context.anyPreferenceDemandByDate = new Map;
|
||
const futureRules = rules.slice(startIndex);
|
||
for (const [offset, rule] of futureRules.entries()) {
|
||
if (!rule.enabled || rule.force !== "preference" || rule.type === "optimization")
|
||
continue;
|
||
if (rule.type === "time_window" && declaredWindowDays(rule, context).length >= rule.placeDays)
|
||
continue;
|
||
const priorityWeight = futureRules.length - offset;
|
||
const dates = rule.type === "time_window" ? context.workingDays.filter((date) => !context.declaredDates.has(date) && compareDate(date, rule.startDate) >= 0 && compareDate(date, rule.endDate) <= 0) : occurrences(rule, context).flatMap((occurrence) => {
|
||
const patterns = patternsFor(rule, occurrence, context);
|
||
return patterns.some((pattern) => pattern.every((date) => declaredPatternDay(date, rule.placeType, context))) ? [] : patterns.flat().filter((date) => !context.declaredDates.has(date));
|
||
});
|
||
for (const date of dates) {
|
||
context.preferenceDemandByDate.set(date, (context.preferenceDemandByDate.get(date) ?? 0) + priorityWeight);
|
||
if (rule.placeType === "any") {
|
||
context.anyPreferenceDemandByDate.set(date, (context.anyPreferenceDemandByDate.get(date) ?? 0) + priorityWeight);
|
||
continue;
|
||
}
|
||
const types = protectedTypes.get(date) ?? new Set;
|
||
types.add(rule.placeType);
|
||
protectedTypes.set(date, types);
|
||
}
|
||
}
|
||
return protectedTypes;
|
||
}
|
||
function occurrences(rule, context) {
|
||
if (rule.type !== "if_then")
|
||
return [];
|
||
let cached = occurrenceCache.get(context);
|
||
if (!cached) {
|
||
cached = new Map;
|
||
occurrenceCache.set(context, cached);
|
||
}
|
||
let dates = cached.get(rule.id);
|
||
if (!dates) {
|
||
dates = [...context.holidays].filter((date) => date >= context.horizon.start && date < context.horizon.end && utcDate(date).getUTCDay() === rule.dayOfWeek).sort(compareDate);
|
||
cached.set(rule.id, dates);
|
||
}
|
||
return dates;
|
||
}
|
||
function workingNeighbors(date, direction, count, context) {
|
||
const result = [];
|
||
for (let current = addDays(date, direction);result.length < count; current = addDays(current, direction)) {
|
||
context.check?.();
|
||
if (isWorking(current, context.holidays))
|
||
result.push(current);
|
||
if (compareDate(current, addDays(context.horizon.start, -400)) < 0 || compareDate(current, addDays(context.horizon.end, 400)) > 0)
|
||
break;
|
||
}
|
||
return result;
|
||
}
|
||
function patternsFor(rule, holiday, context) {
|
||
let cached = calendarPatternCache.get(context);
|
||
if (!cached) {
|
||
cached = new Map;
|
||
calendarPatternCache.set(context, cached);
|
||
}
|
||
const key = `${rule.id}:${holiday}`;
|
||
const existing = cached.get(key);
|
||
if (existing)
|
||
return existing;
|
||
const count = rule.placeDays;
|
||
const make = (before, after) => [
|
||
...workingNeighbors(holiday, -1, before, context),
|
||
...workingNeighbors(holiday, 1, after, context).reverse()
|
||
].sort(compareDate);
|
||
const patterns = [];
|
||
if (rule.placement === "before")
|
||
patterns.push(make(count, 0));
|
||
else if (rule.placement === "after")
|
||
patterns.push(make(0, count));
|
||
else if (rule.placement === "around") {
|
||
for (let before = 1;before < count; before++)
|
||
patterns.push(make(before, count - before));
|
||
} else {
|
||
for (let before = 0;before <= count; before++)
|
||
patterns.push(make(before, count - before));
|
||
}
|
||
const eligible = patterns.filter((pattern) => pattern.length === count && pattern.every((date) => compareDate(date, context.horizon.start) >= 0 && compareDate(date, context.horizon.end) < 0)).sort(compareDateLists);
|
||
cached.set(key, eligible);
|
||
return eligible;
|
||
}
|
||
function buildRequirements(rules, context, force) {
|
||
if (force === "obligation" && rules === context.rules) {
|
||
const cached = obligationRequirementCache.get(context);
|
||
if (cached)
|
||
return cached;
|
||
}
|
||
const requirements = [];
|
||
let index = 0;
|
||
for (const rule of rules) {
|
||
if (!rule.enabled || rule.force !== force || rule.type === "optimization")
|
||
continue;
|
||
if (rule.type === "time_window") {
|
||
const start = compareDate(rule.startDate, context.horizon.start) < 0 ? context.horizon.start : rule.startDate;
|
||
const end = compareDate(rule.endDate, context.horizon.end) >= 0 ? addDays(context.horizon.end, -1) : rule.endDate;
|
||
const candidates = compareDate(start, end) <= 0 ? context.workingDays.filter((date) => !context.declaredDates.has(date) && compareDate(date, start) >= 0 && compareDate(date, end) <= 0) : [];
|
||
const orderedCandidates = candidates.sort((a, b) => preferenceDateConflictScore(rule.placeType, a, context) - preferenceDateConflictScore(rule.placeType, b, context) || compareDate(a, b));
|
||
requirements.push({
|
||
rule,
|
||
requiredPlacements: rule.placeDays - declaredWindowDays(rule, context).length,
|
||
anchor: start,
|
||
index: index++,
|
||
candidates: orderedCandidates
|
||
});
|
||
} else {
|
||
for (const occurrence of occurrences(rule, context)) {
|
||
const patterns = patternsFor(rule, occurrence, context).sort((a, b) => patternConflictScore(rule.placeType, a, context) - patternConflictScore(rule.placeType, b, context) || compareDateLists(a, b));
|
||
requirements.push({
|
||
rule,
|
||
requiredPlacements: Math.min(rule.placeDays, ...patterns.map((pattern) => pattern.filter((date) => !declaredPatternDay(date, rule.placeType, context)).length)),
|
||
anchor: occurrence,
|
||
occurrenceDate: occurrence,
|
||
index: index++,
|
||
patterns
|
||
});
|
||
}
|
||
}
|
||
}
|
||
const ordered = requirements.sort(compareRequirements);
|
||
if (force === "obligation" && rules === context.rules)
|
||
obligationRequirementCache.set(context, ordered);
|
||
return ordered;
|
||
}
|
||
function compareRequirements(a, b) {
|
||
return Number(a.rule.type !== "if_then") - Number(b.rule.type !== "if_then") || compareDate(a.anchor, b.anchor) || a.index - b.index;
|
||
}
|
||
function obligationBranchEstimate(requirements) {
|
||
let estimate = 1;
|
||
for (const requirement of requirements) {
|
||
let branches = requirement.patterns?.length ?? 1;
|
||
if (!requirement.patterns) {
|
||
const candidates = requirement.candidates?.length ?? 0;
|
||
const needed = requirement.requiredPlacements;
|
||
branches = 1;
|
||
for (let index = 1;index <= needed; index++) {
|
||
if (index > candidates) {
|
||
branches = 1;
|
||
break;
|
||
}
|
||
branches = Math.min(EXACT_OBLIGATION_BRANCH_LIMIT + 1, branches * (candidates - needed + index) / index);
|
||
}
|
||
}
|
||
estimate = Math.min(EXACT_OBLIGATION_BRANCH_LIMIT + 1, estimate * branches);
|
||
if (estimate > EXACT_OBLIGATION_BRANCH_LIMIT)
|
||
return estimate;
|
||
}
|
||
return estimate;
|
||
}
|
||
function selectorMatches(selector, type) {
|
||
return selector === "any" || selector === type;
|
||
}
|
||
function declaredWindowDays(rule, context) {
|
||
if (rule.type !== "time_window" || !context.declaredDays.length)
|
||
return [];
|
||
let byRule = declaredWindowCache.get(context);
|
||
if (!byRule) {
|
||
byRule = new Map;
|
||
declaredWindowCache.set(context, byRule);
|
||
}
|
||
let days = byRule.get(rule.id);
|
||
if (!days) {
|
||
days = context.declaredDays.filter((day) => selectorMatches(rule.placeType, day.type) && day.date >= context.horizon.start && day.date < context.horizon.end && day.date >= rule.startDate && day.date <= rule.endDate).sort((a, b) => compareDate(a.date, b.date)).slice(0, rule.placeDays);
|
||
byRule.set(rule.id, days);
|
||
}
|
||
return days;
|
||
}
|
||
function declaredPatternDay(date, selector, context) {
|
||
if (!context.declaredDates.has(date))
|
||
return;
|
||
return context.declaredDays.find((day) => day.date === date && selectorMatches(selector, day.type));
|
||
}
|
||
function patternDateSatisfied(date, rule, state, context) {
|
||
return Boolean(declaredPatternDay(date, rule.placeType, context) || state.placements.has(date) && selectorMatches(rule.placeType, state.placements.get(date).type));
|
||
}
|
||
function selectedOccurrencePattern(rule, occurrence, state, context) {
|
||
const activation = state.earnedActivations.find((item) => item.ruleId === rule.id && item.occurrence === occurrence);
|
||
return activation?.dates.every((date) => patternDateSatisfied(date, rule, state, context)) ? activation.dates : patternsFor(rule, occurrence, context).find((pattern) => pattern.every((date) => patternDateSatisfied(date, rule, state, context)));
|
||
}
|
||
function assignDateVariants(state, date, selector, ruleId, context) {
|
||
context.check();
|
||
if (context.declaredDates.has(date))
|
||
return [];
|
||
const existing = state.placements.get(date);
|
||
if (existing) {
|
||
if (!selectorMatches(selector, existing.type)) {
|
||
return [];
|
||
}
|
||
if (ruleId) {
|
||
const rule = context.rules.find((item) => item.id === ruleId);
|
||
if (rule?.type === "time_window" && (compareDate(date, rule.startDate) < 0 || compareDate(date, rule.endDate) > 0)) {
|
||
return [];
|
||
}
|
||
}
|
||
const result = cloneState(state);
|
||
if (ruleId)
|
||
result.placements.get(date).ruleIds.add(ruleId);
|
||
return [result];
|
||
}
|
||
const balances = state.balances.filter((balance) => balance.remaining > 0 && selectorMatches(selector, balance.type) && compareDate(balance.availableFrom, date) <= 0 && compareDate(date, balance.expiryDate) <= 0).sort((a, b) => {
|
||
if (selector === "any") {
|
||
const sharedTypes = context.sharedTypesByDate.get(date) ?? new Set;
|
||
if (sharedTypes.has(a.type) !== sharedTypes.has(b.type))
|
||
return sharedTypes.has(a.type) ? -1 : 1;
|
||
const protectedTypes = context.protectedTypesByDate.get(date) ?? new Set;
|
||
if (protectedTypes.size && protectedTypes.has(a.type) !== protectedTypes.has(b.type))
|
||
return protectedTypes.has(a.type) ? -1 : 1;
|
||
if (context.reservedTypes.has(a.type) !== context.reservedTypes.has(b.type)) {
|
||
return context.reservedTypes.has(a.type) ? 1 : -1;
|
||
}
|
||
}
|
||
return compareDate(a.expiryDate, b.expiryDate) || compareText(a.id, b.id);
|
||
});
|
||
return balances.map((balance) => {
|
||
const result = cloneState(state);
|
||
const target = result.balances.find((item) => item.id === balance.id);
|
||
target.remaining--;
|
||
result.placements.set(date, {
|
||
date,
|
||
balanceId: target.id,
|
||
type: target.type,
|
||
ruleIds: ruleId ? new Set([ruleId]) : new Set,
|
||
supporting: false
|
||
});
|
||
return result;
|
||
});
|
||
}
|
||
function assignDateToBalance(state, date, balanceId, context, ruleIds = new Set) {
|
||
context.check();
|
||
if (context.declaredDates.has(date))
|
||
return null;
|
||
if (state.placements.has(date)) {
|
||
return null;
|
||
}
|
||
const balance = state.balances.find((item) => item.id === balanceId);
|
||
if (!balance || balance.remaining <= 0 || compareDate(balance.availableFrom, date) > 0 || compareDate(date, balance.expiryDate) > 0) {
|
||
return null;
|
||
}
|
||
if (!mandatoryRelocationDate(date, balance, ruleIds, context))
|
||
return null;
|
||
const result = cloneState(state, new Map(state.placements));
|
||
const target = result.balances.find((item) => item.id === balanceId);
|
||
target.remaining--;
|
||
result.placements.set(date, {
|
||
date,
|
||
balanceId,
|
||
type: balance.type,
|
||
ruleIds: new Set(ruleIds),
|
||
supporting: false
|
||
});
|
||
return result;
|
||
}
|
||
function addEarnedBalance(state, rule, occurrence, dates, context) {
|
||
if (!rule.rewardDays || !rule.rewardType)
|
||
return state;
|
||
const result = cloneState(state);
|
||
const id = `earned:${rule.id}:${occurrence}`;
|
||
const activation = { id, ruleId: rule.id, occurrence, dates: [...dates] };
|
||
if (!result.earnedActivations.some((item) => item.id === id))
|
||
result.earnedActivations.push(activation);
|
||
const bounds = earnedPeriodBounds(state, activation, context);
|
||
if (bounds.availableFrom <= context.request.calculationDate)
|
||
return result;
|
||
if (!result.balances.some((balance) => balance.id === id)) {
|
||
result.balances.push({
|
||
id,
|
||
type: rule.rewardType,
|
||
quantity: rule.rewardDays,
|
||
remaining: rule.rewardDays,
|
||
...bounds,
|
||
earned: true,
|
||
sourceRuleId: rule.id
|
||
});
|
||
}
|
||
return result;
|
||
}
|
||
function earnedPeriodBounds(state, activation, context) {
|
||
const allDates = [...activation.dates, activation.occurrence].sort(compareDate);
|
||
let start = allDates[0] ?? activation.occurrence;
|
||
let end = allDates[allDates.length - 1] ?? activation.occurrence;
|
||
const mergedPeriod = periodData(state, context).find((period) => activation.dates.some((date) => period.placementDates.includes(date) || period.declaredDates?.includes(date)));
|
||
if (mergedPeriod) {
|
||
start = mergedPeriod.start;
|
||
end = mergedPeriod.end;
|
||
}
|
||
while (!isWorking(addDays(start, -1), context.holidays))
|
||
start = addDays(start, -1);
|
||
while (!isWorking(addDays(end, 1), context.holidays))
|
||
end = addDays(end, 1);
|
||
const availableFrom = addDays(end, 1);
|
||
return { availableFrom, expiryDate: addPlanningYears(availableFrom, 1) };
|
||
}
|
||
function finalizeEarnedState(state, context) {
|
||
let reconciled = state;
|
||
for (const rule of context.rules) {
|
||
if (rule.type !== "if_then" || !rule.rewardDays)
|
||
continue;
|
||
for (const occurrence of occurrences(rule, context)) {
|
||
if (reconciled.earnedActivations.some((activation) => activation.ruleId === rule.id && activation.occurrence === occurrence))
|
||
continue;
|
||
const pattern = selectedOccurrencePattern(rule, occurrence, reconciled, context);
|
||
if (pattern)
|
||
reconciled = addEarnedBalance(reconciled, rule, occurrence, pattern, context);
|
||
}
|
||
}
|
||
if (!reconciled.earnedActivations.length)
|
||
return reconciled;
|
||
let result = cloneState(reconciled);
|
||
for (const activation of result.earnedActivations) {
|
||
context.check();
|
||
const bounds = earnedPeriodBounds(result, activation, context);
|
||
if (bounds.availableFrom <= context.request.calculationDate) {
|
||
if ([...result.placements.values()].some((placement) => placement.balanceId === activation.id))
|
||
return null;
|
||
result.balances = result.balances.filter((balance2) => balance2.id !== activation.id);
|
||
continue;
|
||
}
|
||
let balance = result.balances.find((item) => item.id === activation.id);
|
||
if (!balance) {
|
||
const rule = context.rules.find((rule2) => rule2.type === "if_then" && rule2.id === activation.ruleId);
|
||
if (!rule)
|
||
return null;
|
||
result = addEarnedBalance(result, rule, activation.occurrence, activation.dates, context);
|
||
balance = result.balances.find((item) => item.id === activation.id);
|
||
if (!balance)
|
||
continue;
|
||
}
|
||
balance.availableFrom = bounds.availableFrom;
|
||
balance.expiryDate = bounds.expiryDate;
|
||
for (const placement of result.placements.values()) {
|
||
if (placement.balanceId === activation.id && (compareDate(placement.date, balance.availableFrom) < 0 || compareDate(placement.date, balance.expiryDate) > 0))
|
||
return null;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
function* assignDatesVariants(state, dates, rule, context) {
|
||
if (!dates.length)
|
||
return [state];
|
||
const [date, ...rest] = dates;
|
||
if (!isWorking(date, context.holidays) || compareDate(date, context.horizon.start) < 0 || compareDate(date, context.horizon.end) >= 0)
|
||
return [];
|
||
if (context.declaredDates.has(date)) {
|
||
if (declaredPatternDay(date, rule.placeType, context))
|
||
return yield* assignDatesVariants(state, rest, rule, context);
|
||
return [];
|
||
}
|
||
const result = [];
|
||
for (const next of assignDateVariants(state, date, rule.placeType, rule.id, context)) {
|
||
yield;
|
||
result.push(...yield* assignDatesVariants(next, rest, rule, context));
|
||
}
|
||
return result;
|
||
}
|
||
function* satisfyObligations(requirements, state, context, index = 0, solutions, solutionLimit = OBLIGATION_SOLUTION_LIMIT, chooseOrder = true) {
|
||
yield;
|
||
context.check();
|
||
if (index >= requirements.length) {
|
||
const finalized = finalizeRuleCandidate(state, context, state);
|
||
if (!finalized)
|
||
return null;
|
||
if (solutions)
|
||
solutions.push(finalized);
|
||
context.retain?.(finalized);
|
||
return solutions ? null : finalized;
|
||
}
|
||
const requirement = requirements[index];
|
||
const extensionDates = chooseOrder && context.horizon.end > context.request.calculationDate ? state.earnedActivations.map((activation) => state.balances.find((balance) => balance.id === activation.id)?.availableFrom ?? earnedPeriodBounds(state, activation, context).availableFrom) : [];
|
||
const extensions = extensionDates.length ? requirements.slice(index + 1).flatMap((candidate, offset) => (candidate.patterns ? candidate.patterns.some((pattern) => pattern.some((date) => extensionDates.includes(date))) : candidate.requiredPlacements > 0 && candidate.candidates?.some((date) => extensionDates.includes(date))) ? [index + offset + 1] : []) : [];
|
||
if (extensions.length) {
|
||
for (const next of [index, ...extensions]) {
|
||
yield;
|
||
const ordered = next === index ? requirements : [
|
||
...requirements.slice(0, index),
|
||
requirements[next],
|
||
...requirements.slice(index, next),
|
||
...requirements.slice(next + 1)
|
||
];
|
||
const complete = yield* satisfyObligations(ordered, state, context, index, solutions, solutionLimit, false);
|
||
if (complete && !solutions)
|
||
return complete;
|
||
if (solutions && solutionLimit > 0 && solutions.length >= solutionLimit)
|
||
break;
|
||
}
|
||
return null;
|
||
}
|
||
if (requirement.optional) {
|
||
const complete = yield* satisfyObligations(requirements, state, context, index + 1, solutions, solutionLimit);
|
||
if (complete && !solutions)
|
||
return complete;
|
||
}
|
||
if (requirement.patterns) {
|
||
for (const pattern of requirement.patterns) {
|
||
yield;
|
||
for (const assigned of yield* assignDatesVariants(state, pattern, requirement.rule, context)) {
|
||
yield;
|
||
const candidate = finalizeEarnedState(addEarnedBalance(assigned, requirement.rule, requirement.occurrenceDate, pattern, context), context);
|
||
if (!candidate)
|
||
continue;
|
||
const complete = yield* satisfyObligations(requirements, candidate, context, index + 1, solutions, solutionLimit);
|
||
if (complete && !solutions)
|
||
return complete;
|
||
if (solutions && solutionLimit > 0 && solutions.length >= solutionLimit) {
|
||
return null;
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
const candidates = requirement.candidates ?? [];
|
||
const needed = requirement.requiredPlacements;
|
||
const choose = function* (position, picked, current) {
|
||
yield;
|
||
context.check();
|
||
if (picked.length === needed) {
|
||
const finalized = finalizeEarnedState(current, context);
|
||
if (!finalized)
|
||
return null;
|
||
const complete = yield* satisfyObligations(requirements, finalized, context, index + 1, solutions, solutionLimit);
|
||
if (complete && !solutions)
|
||
return complete;
|
||
return null;
|
||
}
|
||
if (candidates.length - position < needed - picked.length) {
|
||
return null;
|
||
}
|
||
for (let i = position;i < candidates.length; i++) {
|
||
yield;
|
||
for (const next of assignDateVariants(current, candidates[i], requirement.rule.placeType, requirement.rule.id, context)) {
|
||
yield;
|
||
const complete = yield* choose(i + 1, [...picked, candidates[i]], next);
|
||
if (complete && !solutions)
|
||
return complete;
|
||
if (solutions && solutionLimit > 0 && solutions.length >= solutionLimit) {
|
||
return null;
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
};
|
||
return yield* choose(0, [], state);
|
||
}
|
||
function releasePlacement(state, date) {
|
||
const result = {
|
||
balances: state.balances.map((balance) => ({ ...balance })),
|
||
placements: new Map(state.placements),
|
||
earnedActivations: state.earnedActivations.map((activation) => ({
|
||
...activation,
|
||
dates: [...activation.dates]
|
||
}))
|
||
};
|
||
const placement = result.placements.get(date);
|
||
result.placements.delete(date);
|
||
result.balances.find((balance) => balance.id === placement.balanceId).remaining++;
|
||
return result;
|
||
}
|
||
function reconcileOptimizationProvenance(state, context, before, objectives = activeObjectiveVector(state, context)) {
|
||
const optimizations = objectives.filter(({ id }) => id.startsWith("optimization:"));
|
||
if (!optimizations.length)
|
||
return state;
|
||
let result = state;
|
||
let observations;
|
||
for (const placement of state.placements.values()) {
|
||
const previous = before.placements.get(placement.date);
|
||
const creditedIds = new Set([...placement.ruleIds, ...previous?.ruleIds ?? []]);
|
||
const credits = optimizations.filter(({ id }) => creditedIds.has(id.slice("optimization:".length)));
|
||
if (!credits.length)
|
||
continue;
|
||
const withoutState = releasePlacement(state, placement.date);
|
||
const withoutPlacement = activeObjectiveVector(withoutState, context);
|
||
const ruleIds = new Set([...placement.ruleIds].filter((id) => !credits.some((objective) => objective.id === `optimization:${id}`)));
|
||
for (const objective of credits) {
|
||
const without = withoutPlacement.find(({ id: id2 }) => id2 === objective.id);
|
||
const id = objective.id.slice("optimization:".length);
|
||
const rule = context.rules.find((rule2) => rule2.id === id && rule2.type === "optimization");
|
||
const compared = compareObjectiveValues(objective.direction, objective.value, without.value);
|
||
let contributes = compared < 0;
|
||
if (compared === 0 && rule.configuration.aggregation === "maximum") {
|
||
observations ??= optimizationObservations(state, context);
|
||
const withoutObservations = optimizationObservations(withoutState, context);
|
||
const summed = { ...rule.configuration, aggregation: "sum" };
|
||
const summedComparison = compareObjectiveValues(objective.direction, evaluateOptimization(summed, observations), evaluateOptimization(summed, withoutObservations));
|
||
contributes = summedComparison < 0 || summedComparison === 0 && rule.configuration.elements === "time-off-periods" && objective.direction === "maximize" && observations.timeOffPeriods.length < withoutObservations.timeOffPeriods.length;
|
||
}
|
||
if (contributes)
|
||
ruleIds.add(id);
|
||
}
|
||
if (ruleIds.size === placement.ruleIds.size && [...ruleIds].every((id) => placement.ruleIds.has(id)))
|
||
continue;
|
||
if (result === state)
|
||
result = cloneState(state);
|
||
result.placements.get(placement.date).ruleIds = ruleIds;
|
||
}
|
||
return result;
|
||
}
|
||
function supportingCalendarBenefit(before, after, context) {
|
||
const observations = optimizationObservations(after, context);
|
||
return evaluateOptimization(OPTIMIZATION_PRESETS.holidayWeekValue, observations) > evaluateOptimization(OPTIMIZATION_PRESETS.holidayWeekValue, before) || evaluateOptimization(OPTIMIZATION_PRESETS.nonWorkingDayGain, observations) > evaluateOptimization(OPTIMIZATION_PRESETS.nonWorkingDayGain, before) || evaluateOptimization(OPTIMIZATION_PRESETS.longestWorkSequence, observations) < evaluateOptimization(OPTIMIZATION_PRESETS.longestWorkSequence, before) || evaluateOptimization(OPTIMIZATION_PRESETS.shortSequenceDeficit, observations) < evaluateOptimization(OPTIMIZATION_PRESETS.shortSequenceDeficit, before);
|
||
}
|
||
function mandatoryRelocationDate(date, balance, ruleIds, context) {
|
||
return [...ruleIds].every((id) => {
|
||
const rule = context.rules.find((item) => item.id === id);
|
||
if (rule?.force !== "obligation")
|
||
return true;
|
||
if (!selectorMatches(rule.placeType, balance.type))
|
||
return false;
|
||
return rule.type === "time_window" ? date >= rule.startDate && date <= rule.endDate : occurrences(rule, context).some((occurrence) => patternsFor(rule, occurrence, context).some((pattern) => pattern.includes(date)));
|
||
});
|
||
}
|
||
function relocationCanReachFree(state, context, balanceId, ruleIds, visited, failed) {
|
||
const key = JSON.stringify([balanceId, [...ruleIds].sort(), [...visited].sort()]);
|
||
if (failed.has(key))
|
||
return false;
|
||
const queue = [{ balanceId, ruleIds }];
|
||
const seen = new Set;
|
||
for (let index = 0;index < queue.length; index++) {
|
||
const entry = queue[index];
|
||
const identity = JSON.stringify([entry.balanceId, [...entry.ruleIds].sort()]);
|
||
if (seen.has(identity))
|
||
continue;
|
||
seen.add(identity);
|
||
const balance = state.balances.find((item) => item.id === entry.balanceId);
|
||
for (const date of context.workingDays) {
|
||
context.check();
|
||
if (visited.has(date) || context.declaredDates.has(date) || date < balance.availableFrom || date > balance.expiryDate || !mandatoryRelocationDate(date, balance, entry.ruleIds, context))
|
||
continue;
|
||
const placement = state.placements.get(date);
|
||
if (!placement)
|
||
return true;
|
||
queue.push({ balanceId: placement.balanceId, ruleIds: placement.ruleIds });
|
||
}
|
||
}
|
||
failed.add(key);
|
||
return false;
|
||
}
|
||
function* relocateForAddition(state, context, date, balanceId, ruleIds, supporting, accept, visited = new Set, failedReachability = new Set, failedSearches = new Set) {
|
||
yield;
|
||
context.check();
|
||
if (visited.has(date) || context.declaredDates.has(date))
|
||
return false;
|
||
const existing = state.placements.get(date);
|
||
if (existing?.balanceId === balanceId && existing.supporting === supporting && existing.ruleIds.size === ruleIds.size && [...existing.ruleIds].every((id) => ruleIds.has(id)))
|
||
return false;
|
||
const key = JSON.stringify([
|
||
date,
|
||
balanceId,
|
||
[...ruleIds].sort(),
|
||
supporting,
|
||
[...visited].sort(),
|
||
state.balances.map((balance) => [balance.id, balance.remaining]),
|
||
[...state.placements.values()].sort((a, b) => compareDate(a.date, b.date)).map((placement) => [
|
||
placement.date,
|
||
placement.balanceId,
|
||
[...placement.ruleIds].sort(),
|
||
placement.supporting
|
||
])
|
||
]);
|
||
if (failedSearches.has(key)) {
|
||
return false;
|
||
}
|
||
const assigned = assignDateToBalance(existing ? releasePlacement(state, date) : state, date, balanceId, context, ruleIds);
|
||
if (!assigned)
|
||
return false;
|
||
assigned.placements.get(date).supporting = supporting;
|
||
if (!existing) {
|
||
const accepted = accept(assigned);
|
||
if (!accepted)
|
||
failedSearches.add(key);
|
||
return accepted;
|
||
}
|
||
const displaced = assigned.balances.find((balance) => balance.id === existing.balanceId);
|
||
const nextVisited = new Set([...visited, date]);
|
||
if (!relocationCanReachFree(assigned, context, existing.balanceId, existing.ruleIds, nextVisited, failedReachability))
|
||
return false;
|
||
for (const destination of context.workingDays) {
|
||
yield;
|
||
if (destination < displaced.availableFrom || destination > displaced.expiryDate)
|
||
continue;
|
||
if (!mandatoryRelocationDate(destination, displaced, existing.ruleIds, context))
|
||
continue;
|
||
if (yield* relocateForAddition(assigned, context, destination, existing.balanceId, existing.ruleIds, existing.supporting, accept, nextVisited, failedReachability, failedSearches))
|
||
return true;
|
||
}
|
||
failedSearches.add(key);
|
||
return false;
|
||
}
|
||
function finalizeRuleCandidate(state, context, before) {
|
||
let result = state;
|
||
const windowCredits = new Map;
|
||
const patternCredits = new Map;
|
||
for (const placement of state.placements.values()) {
|
||
let lostCalendarRequest = false;
|
||
let hasCalendarRequest = false;
|
||
for (const id of placement.ruleIds) {
|
||
const rule = context.rules.find((item) => item.id === id);
|
||
if (rule?.type === "optimization")
|
||
continue;
|
||
const valid = counterfactualRuleValid(placement.date, placement.type, [id], context, state);
|
||
const credited = windowCredits.get(id) ?? 0;
|
||
let withinRequest = true;
|
||
if (rule?.type === "time_window")
|
||
withinRequest = credited < Math.max(0, rule.placeDays - declaredWindowDays(rule, context).length);
|
||
else if (rule?.type === "if_then") {
|
||
if (!patternCredits.has(id))
|
||
patternCredits.set(id, new Set(occurrences(rule, context).flatMap((occurrence) => selectedOccurrencePattern(rule, occurrence, state, context) ?? [])));
|
||
withinRequest = patternCredits.get(id).has(placement.date);
|
||
}
|
||
if (valid && withinRequest) {
|
||
hasCalendarRequest = true;
|
||
if (rule?.type === "time_window")
|
||
windowCredits.set(id, credited + 1);
|
||
continue;
|
||
}
|
||
if (!valid && rule?.force === "obligation")
|
||
return null;
|
||
if (result === state)
|
||
result = cloneState(state);
|
||
result.placements.get(placement.date).ruleIds.delete(id);
|
||
lostCalendarRequest = true;
|
||
}
|
||
const current = result.placements.get(placement.date);
|
||
const previous = before.placements.get(placement.date);
|
||
let supporting = current.supporting;
|
||
if (hasCalendarRequest)
|
||
supporting = false;
|
||
else if (lostCalendarRequest || previous && (previous.balanceId !== placement.balanceId || previous.supporting !== current.supporting)) {
|
||
const balance = result.balances.find((item) => item.id === placement.balanceId);
|
||
supporting = !isAtRisk(balance, context) && (current.supporting || previous?.balanceId === placement.balanceId && previous.supporting || supportingCalendarBenefit(optimizationObservations(releasePlacement(result, placement.date), context), result, context));
|
||
}
|
||
if (supporting !== current.supporting) {
|
||
if (result === state)
|
||
result = cloneState(state);
|
||
result.placements.get(placement.date).supporting = supporting;
|
||
}
|
||
}
|
||
for (const activation of state.earnedActivations) {
|
||
const rule = context.rules.find((item) => item.type === "if_then" && item.id === activation.ruleId);
|
||
if (activation.dates.every((date) => patternDateSatisfied(date, rule, state, context)))
|
||
continue;
|
||
if ([...state.placements.values()].some((placement) => placement.balanceId === activation.id))
|
||
return null;
|
||
result = cloneState(result);
|
||
result.earnedActivations = result.earnedActivations.filter((item) => item.id !== activation.id);
|
||
result.balances = result.balances.filter((balance) => balance.id !== activation.id);
|
||
}
|
||
const finalized = finalizeEarnedState(result, context);
|
||
return finalized && !unsatisfiedObligationCount(finalized, context) ? finalized : null;
|
||
}
|
||
function typedCalendarDates(context) {
|
||
const typedDates = new Set;
|
||
for (const rule of context.rules) {
|
||
if (rule.type === "optimization" || rule.placeType === "any")
|
||
continue;
|
||
const dates = rule.type === "time_window" ? context.workingDays.filter((date) => rule.startDate <= date && date <= rule.endDate) : occurrences(rule, context).flatMap((occurrence) => patternsFor(rule, occurrence, context).flat());
|
||
for (const date of dates)
|
||
typedDates.add(date);
|
||
}
|
||
return typedDates;
|
||
}
|
||
function* calendarPlacementCandidates(state, targetDates, ruleId, context, accept) {
|
||
const missing = targetDates.filter((date) => !state.placements.has(date) && !context.declaredDates.has(date));
|
||
if (!missing.length)
|
||
return false;
|
||
const before = optimizationObservations(state, context);
|
||
const typedDates = typedCalendarDates(context);
|
||
const failed = new Set;
|
||
const rankedDonors = [];
|
||
for (const placement of state.placements.values()) {
|
||
yield;
|
||
context.check();
|
||
if (targetDates.includes(placement.date))
|
||
continue;
|
||
rankedDonors.push({
|
||
date: placement.date,
|
||
objectives: activeObjectiveVector(releasePlacement(state, placement.date), context)
|
||
});
|
||
}
|
||
rankedDonors.sort((a, b) => compareObjectiveLists(a.objectives, b.objectives) || compareDate(b.date, a.date));
|
||
const fill = function* (index, current, additions = []) {
|
||
yield;
|
||
context.check();
|
||
const key = JSON.stringify([
|
||
index,
|
||
current.balances.map((balance) => [balance.id, balance.remaining]),
|
||
[...current.placements.values()].sort((a, b) => compareDate(a.date, b.date)).map((placement) => [
|
||
placement.date,
|
||
targetDates.includes(placement.date) ? typedDates.has(placement.date) ? placement.type : null : placement.type,
|
||
targetDates.includes(placement.date) && !current.balances.find((balance) => balance.id === placement.balanceId).earned ? null : placement.balanceId,
|
||
[...placement.ruleIds].sort(),
|
||
placement.supporting,
|
||
additions.includes(placement.date)
|
||
])
|
||
]);
|
||
if (failed.has(key))
|
||
return false;
|
||
if (index === missing.length) {
|
||
const benefit = supportingCalendarBenefit(before, current, context);
|
||
for (const date2 of additions) {
|
||
const placement = { ...current.placements.get(date2) };
|
||
current.placements.set(date2, placement);
|
||
const balance = current.balances.find((item) => item.id === placement.balanceId);
|
||
placement.supporting = benefit && !isAtRisk(balance, context);
|
||
}
|
||
const accepted = accept(current, additions.length > 0);
|
||
if (!accepted)
|
||
failed.add(key);
|
||
return accepted;
|
||
}
|
||
const date = missing[index];
|
||
for (const balance of current.balances) {
|
||
if (balance.remaining <= 0 || date < balance.availableFrom || date > balance.expiryDate)
|
||
continue;
|
||
const assigned = assignDateToBalance(current, date, balance.id, context, new Set([ruleId]));
|
||
if (!assigned)
|
||
continue;
|
||
if (yield* fill(index + 1, assigned, [...additions, date]))
|
||
return true;
|
||
}
|
||
const donors = new Set;
|
||
for (const donor of rankedDonors) {
|
||
yield;
|
||
const source = current.placements.get(donor.date);
|
||
if (!source)
|
||
continue;
|
||
const balance = current.balances.find((item) => item.id === source.balanceId);
|
||
if (date < balance.availableFrom || date > balance.expiryDate || !mandatoryRelocationDate(date, balance, source.ruleIds, context))
|
||
continue;
|
||
const without = releasePlacement(current, source.date);
|
||
const identity = JSON.stringify([
|
||
source.balanceId,
|
||
[...source.ruleIds].sort(),
|
||
source.supporting,
|
||
activeObjectiveVector(without, context)
|
||
]);
|
||
if (donors.has(identity))
|
||
continue;
|
||
donors.add(identity);
|
||
const assigned = assignDateToBalance(without, date, source.balanceId, context, source.ruleIds);
|
||
if (!assigned)
|
||
continue;
|
||
assigned.placements.get(date).supporting = source.supporting;
|
||
if (yield* fill(index + 1, assigned, additions))
|
||
return true;
|
||
}
|
||
failed.add(key);
|
||
return false;
|
||
};
|
||
return yield* fill(0, state);
|
||
}
|
||
function* holidayWeekPlacementCandidates(state, ruleId, context, accept) {
|
||
for (const week of context.holidayWeeks)
|
||
yield* calendarPlacementCandidates(state, week.dates, ruleId, context, accept);
|
||
}
|
||
function* timeOffPeriodPlacementCandidates(state, ruleId, context, accept) {
|
||
const periods = periodData(state, context);
|
||
for (let index = 1;index < periods.length; index++) {
|
||
const dates = context.workingDays.filter((date) => date > periods[index - 1].end && date < periods[index].start);
|
||
if (dates.length > 1)
|
||
yield* calendarPlacementCandidates(state, dates, ruleId, context, accept);
|
||
}
|
||
}
|
||
function evaluateRuleCandidate(before, candidate, context, throughIndex, addition = false, baseline = activeObjectiveVector(before, context, throughIndex), incumbentVector = objectiveVector(before, context)) {
|
||
if (!candidate)
|
||
return;
|
||
const state = finalizeRuleCandidate(candidate, context, before);
|
||
if (!state)
|
||
return;
|
||
const active = [];
|
||
let comparison = 0;
|
||
let incumbentComparison = 0;
|
||
for (const objective of activeObjectives(state, context)) {
|
||
const index = active.length;
|
||
active.push(objective);
|
||
if (index <= throughIndex && comparison === 0) {
|
||
comparison = compareObjectiveValues(objective.direction, objective.value, baseline[index].value);
|
||
if (comparison > 0)
|
||
return;
|
||
}
|
||
if (incumbentComparison === 0)
|
||
incumbentComparison = compareObjectiveValues(objective.direction, objective.value, incumbentVector.objectives[index + 1].value);
|
||
if (incumbentComparison > 0 && (comparison < 0 || index >= throughIndex))
|
||
return addition && comparison === 0 ? undefined : { state };
|
||
}
|
||
const vector = objectiveVector(state, context, active);
|
||
if (compareObjectiveLists(vector.objectives, incumbentVector.objectives) < 0)
|
||
context.retain?.(state, undefined, vector);
|
||
if (addition && comparison === 0)
|
||
return;
|
||
return { state, vector };
|
||
}
|
||
function* workSequencePlacementCandidates(state, rule, context, consider) {
|
||
const configuration = rule.configuration;
|
||
if (configuration.direction !== "minimize")
|
||
return;
|
||
const sequences = workSequenceDates(state, context).filter(({ dates, internal }) => dates.length > 0 && (!configuration.conditions.includes("internal") || internal));
|
||
const bundles = [];
|
||
if (configuration.aggregation === "count")
|
||
bundles.push(...sequences.map(({ dates }) => dates.map((date) => [date])));
|
||
else if (configuration.measure === "work-sequence-deficit") {
|
||
const short = sequences.filter(({ dates }) => dates.length < configuration.thresholdDays);
|
||
if (configuration.aggregation === "maximum") {
|
||
const shortest = Math.min(...short.map(({ dates }) => dates.length));
|
||
bundles.push(short.filter(({ dates }) => dates.length === shortest).flatMap(({ dates }) => dates.map((date) => [date])));
|
||
} else
|
||
bundles.push(...short.map(({ dates }) => dates.map((date) => [date])));
|
||
} else if (configuration.measure === "work-sequence-length" && configuration.aggregation === "maximum") {
|
||
const maximum = Math.max(0, ...sequences.map(({ dates }) => dates.length));
|
||
const tied = sequences.filter(({ dates }) => dates.length === maximum);
|
||
if (tied.length > 1) {
|
||
for (const offset of [0, 1]) {
|
||
const bundle = [];
|
||
for (const { dates } of tied) {
|
||
const middle = Math.floor((dates.length - 1 + offset) / 2);
|
||
const centered = dates.map((date, index) => ({ date, index })).sort((a, b) => Math.abs(a.index - middle) - Math.abs(b.index - middle) || compareDate(a.date, b.date));
|
||
const eligible = [
|
||
...new Set(state.balances.filter((balance) => balance.remaining > 0).map((balance) => centered.find(({ date }) => balance.availableFrom <= date && date <= balance.expiryDate)?.date).filter((date) => date !== undefined))
|
||
];
|
||
if (!eligible.length)
|
||
break;
|
||
bundle.push(eligible.sort((a, b) => centered.findIndex(({ date }) => date === a) - centered.findIndex(({ date }) => date === b)));
|
||
}
|
||
if (bundle.length === tied.length)
|
||
bundles.push(bundle);
|
||
}
|
||
}
|
||
}
|
||
const before = optimizationObservations(state, context);
|
||
const available = state.balances.reduce((total, balance) => total + balance.remaining, 0);
|
||
const typedDates = typedCalendarDates(context);
|
||
const failedAssignments = new Set;
|
||
function* assignBundle(candidate, slots, dates = []) {
|
||
yield;
|
||
context.check();
|
||
const key = JSON.stringify([
|
||
slots,
|
||
dates,
|
||
candidate.balances.map(({ id, remaining }) => [id, remaining]),
|
||
dates.map((date) => {
|
||
const placement = candidate.placements.get(date);
|
||
const balance = candidate.balances.find((item) => item.id === placement.balanceId);
|
||
return [
|
||
typedDates.has(date) ? placement.type : undefined,
|
||
balance.earned ? balance.id : undefined
|
||
];
|
||
})
|
||
]);
|
||
if (failedAssignments.has(key))
|
||
return false;
|
||
if (dates.length === slots.length) {
|
||
const supporting = supportingCalendarBenefit(before, candidate, context);
|
||
for (const date of dates) {
|
||
const placement = candidate.placements.get(date);
|
||
const balance = candidate.balances.find((item) => item.id === placement.balanceId);
|
||
placement.supporting = supporting && !isAtRisk(balance, context);
|
||
}
|
||
const accepted = consider(candidate);
|
||
if (!accepted)
|
||
failedAssignments.add(key);
|
||
return accepted;
|
||
}
|
||
for (const date of slots[dates.length]) {
|
||
for (const next of assignDateVariants(candidate, date, "any", rule.id, context))
|
||
if (yield* assignBundle(next, slots, [...dates, date]))
|
||
return true;
|
||
}
|
||
failedAssignments.add(key);
|
||
return false;
|
||
}
|
||
const examined = new Set;
|
||
for (const slots of bundles) {
|
||
yield;
|
||
const key = JSON.stringify(slots);
|
||
if (slots.length <= 1 || slots.length > available || examined.has(key))
|
||
continue;
|
||
examined.add(key);
|
||
yield* assignBundle(state, slots);
|
||
}
|
||
}
|
||
function* optimizeRulePlacements(state, context, throughIndex, allowAdd, rule) {
|
||
let result = state;
|
||
const addingBalanceQuantity = allowAdd && rule?.type === "optimization" && rule.configuration.elements === "leave-balances" && rule.configuration.measure === "unplaced-quantity" && rule.configuration.aggregation === "sum" && rule.configuration.direction === "minimize";
|
||
const equivalentAdditionFunding = addingBalanceQuantity && throughIndex === 0 && !context.rules.some((item) => item.enabled && item.type === "if_then") && context.rules.every((item) => !item.enabled || item.type !== "optimization" || item.configuration.elements !== "leave-balances" || item.configuration.aggregation !== "maximum");
|
||
const fundingWindows = context.rules.filter((item) => item.enabled && item.type === "time_window");
|
||
const preferencePrefix = context.rules.filter((item) => item.enabled && item.force === "preference").slice(0, throughIndex + 1);
|
||
const prefixBounds = preferencePrefix.map((item, index) => {
|
||
if (index === 0)
|
||
return item.type === "optimization" && item.configuration.elements === "leave-balances" && item.configuration.measure === "unplaced-quantity" && item.configuration.aggregation === "sum" && item.configuration.direction === "minimize" ? 0 : undefined;
|
||
if (item.type === "time_window")
|
||
return item.placeDays;
|
||
if (item.type === "optimization" && item.configuration.elements === "public-holiday-weeks" && item.configuration.measure === "public-holiday-week-value" && item.configuration.direction === "maximize")
|
||
return evaluateOptimization(item.configuration, {
|
||
leaveBalances: [],
|
||
publicHolidayWeeks: context.holidayWeeks.map(({ value }) => ({
|
||
value,
|
||
complete: true
|
||
})),
|
||
timeOffPeriods: [],
|
||
workSequences: [],
|
||
leavePlacements: []
|
||
});
|
||
return;
|
||
});
|
||
const dateInvariantObjectives = context.rules.filter((item) => item.force === "preference").every((item) => item.type === "optimization" && (item.configuration.elements === "leave-balances" || item.configuration.elements === "leave-placements"));
|
||
while (true) {
|
||
yield;
|
||
context.check();
|
||
const active = activeObjectiveVector(result, context);
|
||
const baseline = active.slice(0, throughIndex + 1);
|
||
const beforeVector = objectiveVector(result, context, active);
|
||
context.retain?.(result, undefined, beforeVector);
|
||
if (allowAdd && prefixBounds.length > 0 && prefixBounds.every((bound, index) => bound !== undefined && active[index].value === bound)) {
|
||
return result;
|
||
}
|
||
const genericStateKey = allowAdd && result.balances.every(({ remaining }) => remaining === 0) && !context.rules.some((item) => item.enabled && item.type === "if_then") ? preferenceStateKey(result) : undefined;
|
||
const reuseGeneric = genericStateKey !== undefined && context.completedGenericState === genericStateKey;
|
||
const compareEquivalentFunding = equivalentAdditionFunding && result.earnedActivations.length === 0 && Number.isSafeInteger(result.balances.reduce((sum, balance) => sum + balance.remaining, 0));
|
||
let beforeCalendar;
|
||
let best = result;
|
||
let bestVector = beforeVector;
|
||
const consider = (candidate, addition = false) => {
|
||
const evaluated = evaluateRuleCandidate(result, candidate, context, throughIndex, addition, baseline, bestVector);
|
||
if (!evaluated)
|
||
return false;
|
||
if (!evaluated.vector)
|
||
return true;
|
||
const compared = compareObjectiveLists(evaluated.vector.objectives, bestVector.objectives);
|
||
if (compared >= 0)
|
||
return true;
|
||
best = evaluated.state;
|
||
bestVector = evaluated.vector;
|
||
return true;
|
||
};
|
||
const dates = [...context.workingDays].sort((a, b) => Number(result.placements.has(a)) - Number(result.placements.has(b)));
|
||
const moveDates = result.placements.size <= 24 ? context.workingDays : context.workingDays.filter((date, index) => !isWorking(addDays(date, -1), context.holidays) || !isWorking(addDays(date, 1), context.holidays) || context.declaredDates.has(addDays(date, -1)) || context.declaredDates.has(addDays(date, 1)) || index % 7 === 0 || context.rules.some((item) => item.type === "time_window" && date >= item.startDate && date <= item.endDate));
|
||
if (allowAdd && rule?.type === "optimization" && rule.configuration.elements === "work-sequences")
|
||
yield* workSequencePlacementCandidates(result, rule, context, (candidate) => consider(candidate, true));
|
||
if (allowAdd && rule?.type === "optimization" && rule.configuration.elements === "public-holiday-weeks" && rule.configuration.conditions.includes("complete") && rule.configuration.direction === "maximize")
|
||
yield* holidayWeekPlacementCandidates(result, rule.id, context, consider);
|
||
if (allowAdd && rule?.type === "optimization" && rule.configuration.elements === "time-off-periods" && (rule.configuration.aggregation === "maximum" && rule.configuration.direction === "maximize" || rule.configuration.aggregation === "count" && rule.configuration.direction === "minimize"))
|
||
yield* timeOffPeriodPlacementCandidates(result, rule.id, context, consider);
|
||
const deferGeneric = allowAdd && best !== result && compareObjectiveLists(bestVector.objectives.slice(1, throughIndex + 2), baseline) < 0;
|
||
for (const date of reuseGeneric || deferGeneric ? [] : dates) {
|
||
yield;
|
||
context.check();
|
||
if (context.declaredDates.has(date))
|
||
continue;
|
||
const existing = result.placements.get(date);
|
||
if (!existing && allowAdd) {
|
||
if (rule?.type === "time_window" && (date < rule.startDate || date > rule.endDate))
|
||
continue;
|
||
const evaluatedFunding = new Set;
|
||
for (const balance of result.balances) {
|
||
yield;
|
||
if (rule?.type === "time_window" && !selectorMatches(rule.placeType, balance.type))
|
||
continue;
|
||
if (balance.remaining <= 0 || balance.availableFrom > date || balance.expiryDate < date)
|
||
continue;
|
||
const fundingKey = compareEquivalentFunding && isAtRisk(balance, context) ? `${balance.expiryDate}:${fundingWindows.map((window) => Number(date >= window.startDate && date <= window.endDate && selectorMatches(window.placeType, balance.type))).join("")}` : undefined;
|
||
if (fundingKey !== undefined && evaluatedFunding.has(fundingKey)) {
|
||
continue;
|
||
}
|
||
const assigned = assignDateToBalance(result, date, balance.id, context, rule ? new Set([rule.id]) : new Set);
|
||
if (assigned && rule?.type === "optimization" && !isAtRisk(balance, context)) {
|
||
beforeCalendar ??= optimizationObservations(result, context);
|
||
assigned.placements.get(date).supporting = supportingCalendarBenefit(beforeCalendar, assigned, context);
|
||
}
|
||
const evaluated = consider(assigned, true);
|
||
if (evaluated && fundingKey !== undefined)
|
||
evaluatedFunding.add(fundingKey);
|
||
}
|
||
}
|
||
if (!existing || addingBalanceQuantity && best !== result)
|
||
continue;
|
||
const without = releasePlacement(result, date);
|
||
consider(without);
|
||
for (const balance of without.balances) {
|
||
yield;
|
||
if (balance.id === existing.balanceId || balance.remaining <= 0 || balance.availableFrom > date || balance.expiryDate < date)
|
||
continue;
|
||
const reassigned = assignDateToBalance(without, date, balance.id, context, existing.ruleIds);
|
||
if (reassigned)
|
||
reassigned.placements.get(date).supporting = existing.supporting && !isAtRisk(balance, context);
|
||
consider(reassigned);
|
||
}
|
||
for (const destination of moveDates) {
|
||
yield;
|
||
context.check();
|
||
if (destination === date || context.declaredDates.has(destination))
|
||
continue;
|
||
const other = without.placements.get(destination);
|
||
if (other) {
|
||
if (other.balanceId === existing.balanceId)
|
||
continue;
|
||
const swapped = releasePlacement(without, destination);
|
||
const first = assignDateToBalance(swapped, destination, existing.balanceId, context, existing.ruleIds);
|
||
const second = first && assignDateToBalance(first, date, other.balanceId, context, other.ruleIds);
|
||
if (second) {
|
||
second.placements.get(destination).supporting = existing.supporting;
|
||
second.placements.get(date).supporting = other.supporting;
|
||
}
|
||
consider(second);
|
||
} else {
|
||
const moved = assignDateToBalance(without, destination, existing.balanceId, context, existing.ruleIds);
|
||
if (moved)
|
||
moved.placements.get(destination).supporting = existing.supporting;
|
||
if (moved && dateInvariantObjectives && compareObjectiveLists(tieBreakObjectives(moved), beforeVector.objectives.slice(-2)) >= 0) {
|
||
continue;
|
||
}
|
||
consider(moved);
|
||
}
|
||
}
|
||
}
|
||
if (allowAdd && (addingBalanceQuantity || rule?.type === "time_window" && Number(active[throughIndex].value) < rule.placeDays) && compareObjectiveLists(bestVector.objectives.slice(1, throughIndex + 2), baseline) === 0) {
|
||
for (const balance of result.balances) {
|
||
if (balance.remaining <= 0)
|
||
continue;
|
||
for (const date of result.placements.keys()) {
|
||
yield;
|
||
if (date < balance.availableFrom || date > balance.expiryDate)
|
||
continue;
|
||
const sourceRuleApplies = rule?.type !== "time_window" || date >= rule.startDate && date <= rule.endDate && selectorMatches(rule.placeType, balance.type);
|
||
yield* relocateForAddition(result, context, date, balance.id, rule && sourceRuleApplies ? new Set([rule.id]) : new Set, false, (candidate) => {
|
||
if (rule?.type === "optimization" && !isAtRisk(balance, context)) {
|
||
beforeCalendar ??= optimizationObservations(result, context);
|
||
candidate.placements.set(date, {
|
||
...candidate.placements.get(date),
|
||
supporting: supportingCalendarBenefit(beforeCalendar, candidate, context)
|
||
});
|
||
}
|
||
return consider(candidate, true);
|
||
});
|
||
}
|
||
}
|
||
}
|
||
if (best === result) {
|
||
if (genericStateKey !== undefined)
|
||
context.completedGenericState = genericStateKey;
|
||
return result;
|
||
}
|
||
best = reconcileOptimizationProvenance(best, context, result, bestVector.objectives);
|
||
context.retain?.(best);
|
||
result = best;
|
||
}
|
||
}
|
||
function associateCalendarPreference(state, rule, context) {
|
||
const result = cloneState(state);
|
||
const dates = rule.type === "time_window" ? [...result.placements.values()].filter((placement) => placement.date >= rule.startDate && placement.date <= rule.endDate && selectorMatches(rule.placeType, placement.type)).sort((a, b) => Number(b.ruleIds.has(rule.id)) - Number(a.ruleIds.has(rule.id))).slice(0, Math.max(0, rule.placeDays - declaredWindowDays(rule, context).length)).map((placement) => placement.date) : occurrences(rule, context).flatMap((occurrence) => selectedOccurrencePattern(rule, occurrence, result, context) ?? []);
|
||
for (const date of dates) {
|
||
const placement = result.placements.get(date);
|
||
if (!placement)
|
||
continue;
|
||
placement.ruleIds.add(rule.id);
|
||
placement.supporting = false;
|
||
}
|
||
return result;
|
||
}
|
||
function* preferencePatternVariants(state, pattern, rule, context) {
|
||
let variants = [state];
|
||
for (const date of pattern) {
|
||
yield;
|
||
const next = [];
|
||
for (const current of variants) {
|
||
yield;
|
||
const existing = current.placements.get(date);
|
||
if (!existing || selectorMatches(rule.placeType, existing.type)) {
|
||
if (declaredPatternDay(date, rule.placeType, context))
|
||
next.push(current);
|
||
else
|
||
next.push(...assignDateVariants(current, date, rule.placeType, rule.id, context));
|
||
continue;
|
||
}
|
||
const without = releasePlacement(current, date);
|
||
for (const balance of without.balances) {
|
||
yield;
|
||
if (!selectorMatches(rule.placeType, balance.type))
|
||
continue;
|
||
const reassigned = assignDateToBalance(without, date, balance.id, context, new Set([rule.id]));
|
||
if (reassigned)
|
||
next.push(reassigned);
|
||
}
|
||
for (const other of without.placements.values()) {
|
||
yield;
|
||
if (pattern.includes(other.date) || !selectorMatches(rule.placeType, other.type))
|
||
continue;
|
||
const released = releasePlacement(without, other.date);
|
||
const first = assignDateToBalance(released, date, other.balanceId, context, new Set([...other.ruleIds, rule.id]));
|
||
const swapped = first && assignDateToBalance(first, other.date, existing.balanceId, context, existing.ruleIds);
|
||
if (!swapped)
|
||
continue;
|
||
swapped.placements.get(date).supporting = other.supporting;
|
||
swapped.placements.get(other.date).supporting = existing.supporting;
|
||
next.push(swapped);
|
||
}
|
||
}
|
||
variants = next;
|
||
if (!variants.length)
|
||
break;
|
||
}
|
||
return variants;
|
||
}
|
||
function* preferenceIfThen(state, rule, context, preferenceIndex) {
|
||
const matchingOccurrences = occurrences(rule, context);
|
||
let bestState = state;
|
||
let bestCount = 0;
|
||
const baseline = activeObjectiveVector(state, context, preferenceIndex);
|
||
const search = function* (index, current, count) {
|
||
yield;
|
||
context.check();
|
||
const maximumCount = count + matchingOccurrences.length - index;
|
||
if (maximumCount < bestCount && baseline.slice(0, preferenceIndex).every((objective) => {
|
||
if (objective.direction === "minimize")
|
||
return objective.value === 0;
|
||
const earlier = context.rules.find((item) => `preference:${item.id}` === objective.id);
|
||
return earlier && objective.value === (earlier.type === "time_window" ? earlier.placeDays : occurrences(earlier, context).length);
|
||
})) {
|
||
return;
|
||
}
|
||
if (index >= matchingOccurrences.length) {
|
||
const finalized = finalizeRuleCandidate(current, context, state);
|
||
if (!finalized) {
|
||
return;
|
||
}
|
||
if (unsatisfiedObligationCount(finalized, context) || compareObjectiveLists(activeObjectiveVector(finalized, context, preferenceIndex), baseline) > 0)
|
||
return;
|
||
context.retain?.(finalized);
|
||
const better = compareObligationPreviews({ state: finalized }, { state: bestState }, context) < 0;
|
||
if (better) {
|
||
bestCount = count;
|
||
bestState = finalized;
|
||
}
|
||
return;
|
||
}
|
||
const occurrence = matchingOccurrences[index];
|
||
const patterns = [...patternsFor(rule, occurrence, context)].sort((a, b) => patternConflictScore(rule.placeType, a, context) - patternConflictScore(rule.placeType, b, context) || compareDateLists(a, b));
|
||
for (const pattern of patterns) {
|
||
yield;
|
||
const variants = yield* preferencePatternVariants(current, pattern, rule, context);
|
||
for (const variant of variants) {
|
||
yield;
|
||
const finalized = finalizeEarnedState(addEarnedBalance(variant, rule, occurrence, pattern, context), context);
|
||
if (!finalized)
|
||
continue;
|
||
yield* search(index + 1, finalized, count + 1);
|
||
}
|
||
}
|
||
yield* search(index + 1, current, count);
|
||
};
|
||
yield* search(0, state, 0);
|
||
context.retain?.(bestState);
|
||
return { state: bestState, count: bestCount };
|
||
}
|
||
function preferenceDateConflictScore(selector, date, context) {
|
||
const protectedTypes = context.protectedTypesByDate.get(date);
|
||
const demand = context.preferenceDemandByDate.get(date) ?? 0;
|
||
const anyDemand = context.anyPreferenceDemandByDate.get(date) ?? 0;
|
||
if (!protectedTypes?.size && !demand)
|
||
return 0;
|
||
if (selector === "any")
|
||
return -(demand * 2 + (protectedTypes?.size ?? 0));
|
||
if (protectedTypes?.has(selector))
|
||
return -(demand * 2 + 1);
|
||
if (protectedTypes?.size)
|
||
return anyDemand ? -anyDemand : protectedTypes.size;
|
||
return demand ? -demand : 0;
|
||
}
|
||
function patternConflictScore(selector, pattern, context) {
|
||
return pattern.reduce((score, date) => score + preferenceDateConflictScore(selector, date, context), 0);
|
||
}
|
||
function preferenceReason(rule, count, context, state) {
|
||
const requested = rule.type === "if_then" ? occurrences(rule, context).length : rule.placeDays;
|
||
if (count >= requested)
|
||
return;
|
||
const candidateDates = rule.type === "time_window" ? context.workingDays.filter((date) => !context.declaredDates.has(date) && compareDate(date, rule.startDate) >= 0 && compareDate(date, rule.endDate) <= 0) : occurrences(rule, context).flatMap((occurrence) => patternsFor(rule, occurrence, context).flat());
|
||
if (!candidateDates.length)
|
||
return reason("horizon", `Preference "${rule.name}" has no placeable date in the horizon.`, [rule.id]);
|
||
const matchingBalances = state.balances.filter((balance) => selectorMatches(rule.placeType, balance.type));
|
||
const availableBalances = matchingBalances.filter((balance) => candidateDates.some((date) => compareDate(balance.availableFrom, date) <= 0 && compareDate(date, balance.expiryDate) <= 0));
|
||
const currentRuleIndex = context.rules.findIndex((item) => item.id === rule.id);
|
||
const consumedByHigherPriority = matchingBalances.some((balance) => balance.remaining === 0 && [...state.placements.values()].some((placement) => placement.balanceId === balance.id && [...placement.ruleIds].some((id) => {
|
||
const index = context.rules.findIndex((item) => item.id === id);
|
||
return index >= 0 && (context.rules[index].force === "obligation" || index < currentRuleIndex);
|
||
})));
|
||
const freeEligibleDate = candidateDates.some((date) => !state.placements.has(date) && state.balances.some((balance) => balance.remaining > 0 && selectorMatches(rule.placeType, balance.type) && compareDate(balance.availableFrom, date) <= 0 && compareDate(date, balance.expiryDate) <= 0));
|
||
const compatibleExisting = candidateDates.some((date) => {
|
||
const placement = state.placements.get(date);
|
||
return placement && selectorMatches(rule.placeType, placement.type);
|
||
});
|
||
const blockedByHigherPriority = candidateDates.some((date) => {
|
||
const placement = state.placements.get(date);
|
||
return placement && !selectorMatches(rule.placeType, placement.type) && [...placement.ruleIds].some((id) => {
|
||
const index = context.rules.findIndex((item) => item.id === id);
|
||
return index >= 0 && (context.rules[index].force === "obligation" || index < currentRuleIndex);
|
||
});
|
||
});
|
||
let code;
|
||
if (blockedByHigherPriority && !freeEligibleDate && !compatibleExisting)
|
||
code = "higher-priority";
|
||
else if (!matchingBalances.length && !compatibleExisting)
|
||
code = "type";
|
||
else if (!availableBalances.length)
|
||
code = "availability";
|
||
else if (consumedByHigherPriority && !freeEligibleDate && !compatibleExisting)
|
||
code = "higher-priority";
|
||
else
|
||
code = "capacity";
|
||
return reason(code, `Preference "${rule.name}" could not be completely satisfied.`, [rule.id]);
|
||
}
|
||
function* applyPreferenceRules(state, preferenceRules, context) {
|
||
let result = state;
|
||
const preferences = [];
|
||
for (let preferenceIndex = 0;preferenceIndex < preferenceRules.length; preferenceIndex++) {
|
||
yield;
|
||
result = yield* applyPreferenceStep(result, preferenceRules, preferenceIndex, preferences, context);
|
||
}
|
||
return { state: result, preferences };
|
||
}
|
||
function* applyPreferenceStep(state, preferenceRules, preferenceIndex, preferences, context) {
|
||
let result = state;
|
||
const apply = function* (index) {
|
||
const rule = preferenceRules[index];
|
||
context.protectedTypesByDate = futurePreferenceProtection(preferenceRules, index + 1, context);
|
||
if (context.completedPreferenceStates.get(index) === preferenceStateKey(result)) {
|
||
return;
|
||
}
|
||
if (rule.type === "optimization")
|
||
result = yield* optimizeRulePlacements(result, context, index, true, rule);
|
||
else if (rule.type === "time_window")
|
||
result = associateCalendarPreference(yield* optimizeRulePlacements(result, context, index, true, rule), rule, context);
|
||
else
|
||
result = associateCalendarPreference((yield* preferenceIfThen(result, rule, context, index)).state, rule, context);
|
||
context.completedPreferenceStates.set(index, preferenceStateKey(result));
|
||
};
|
||
yield* apply(preferenceIndex);
|
||
let previous;
|
||
do {
|
||
previous = activeObjectiveVector(result, context);
|
||
const entitlements = result.balances.map(({ id, quantity, availableFrom, expiryDate }) => `${id}:${quantity}:${availableFrom}:${expiryDate}`).join("|");
|
||
for (let index = 0;index < preferenceIndex; index++) {
|
||
yield;
|
||
yield* apply(index);
|
||
}
|
||
if (compareObjectiveLists(activeObjectiveVector(result, context), previous) < 0 || result.balances.map(({ id, quantity, availableFrom, expiryDate }) => `${id}:${quantity}:${availableFrom}:${expiryDate}`).join("|") !== entitlements)
|
||
yield* apply(preferenceIndex);
|
||
} while (compareObjectiveLists(activeObjectiveVector(result, context), previous) < 0);
|
||
preferences.splice(0, preferences.length, ...preferenceResultsForState(result, context).map((preference) => ({
|
||
...preference,
|
||
reason: preferenceReason(context.rules.find((rule) => rule.type !== "optimization" && rule.id === preference.ruleId), preference.satisfied, context, result)
|
||
})));
|
||
return result;
|
||
}
|
||
function preferenceStateKey(state) {
|
||
return JSON.stringify([
|
||
state.balances,
|
||
[...state.placements].map(([date, placement]) => [
|
||
date,
|
||
{ ...placement, ruleIds: [...placement.ruleIds] }
|
||
]),
|
||
state.earnedActivations
|
||
]);
|
||
}
|
||
function placementTieKey(state) {
|
||
return [...state.placements.keys()].sort().join("|");
|
||
}
|
||
function expiryTieKey(state) {
|
||
return [...state.placements.values()].map((placement) => state.balances.find((item) => item.id === placement.balanceId)?.expiryDate ?? "").sort(compareDate).join("|");
|
||
}
|
||
function activeObjectiveVector(state, context, throughIndex = Number.POSITIVE_INFINITY) {
|
||
return [...activeObjectives(state, context, throughIndex)];
|
||
}
|
||
function* activeObjectives(state, context, throughIndex = Number.POSITIVE_INFINITY) {
|
||
let preferences;
|
||
let balances;
|
||
let calendar;
|
||
let index = 0;
|
||
for (const rule of context.rules) {
|
||
if (!rule.enabled || rule.force !== "preference")
|
||
continue;
|
||
if (index++ > throughIndex)
|
||
return;
|
||
if (rule.type === "optimization") {
|
||
const observations = rule.configuration.elements === "leave-balances" ? balances ??= {
|
||
leaveBalances: optimizationBalanceObservations(state, context),
|
||
publicHolidayWeeks: [],
|
||
timeOffPeriods: [],
|
||
workSequences: [],
|
||
leavePlacements: []
|
||
} : calendar ??= optimizationObservations(state, context);
|
||
yield {
|
||
id: `optimization:${rule.id}`,
|
||
direction: rule.configuration.direction,
|
||
value: evaluateStateOptimization(rule.configuration, state, context, observations),
|
||
label: rule.name
|
||
};
|
||
} else {
|
||
preferences ??= preferenceResultsForState(state, context);
|
||
yield {
|
||
id: `preference:${rule.id}`,
|
||
direction: "maximize",
|
||
value: preferences.find((preference) => preference.ruleId === rule.id)?.satisfied ?? 0,
|
||
label: rule.name
|
||
};
|
||
}
|
||
}
|
||
}
|
||
function tieBreakObjectives(state) {
|
||
return [
|
||
{
|
||
id: "balance-expiry",
|
||
direction: "minimize",
|
||
value: expiryTieKey(state),
|
||
label: "Balance expiry tie-break"
|
||
},
|
||
{
|
||
id: "placement-date",
|
||
direction: "minimize",
|
||
value: placementTieKey(state),
|
||
label: "Placement date tie-break"
|
||
}
|
||
];
|
||
}
|
||
function obligationPreviewObjectives(preview, context) {
|
||
return [...activeObjectiveVector(preview.state, context), ...tieBreakObjectives(preview.state)];
|
||
}
|
||
function compareObligationPreviews(a, b, context) {
|
||
return compareObjectiveLists(obligationPreviewObjectives(a, context), obligationPreviewObjectives(b, context));
|
||
}
|
||
function isAtRisk(balance, context) {
|
||
return compareDate(balance.expiryDate, context.horizon.start) >= 0 && compareDate(balance.expiryDate, context.horizon.end) <= 0;
|
||
}
|
||
function isNaturalNonWorkingDate(date, context) {
|
||
return context.calendarIndex.has(date) ? !context.workingCalendar.has(date) : !isWorkingPlanningDate(date);
|
||
}
|
||
function calendarDateAt(index, context) {
|
||
return context.calendarDays[index] ?? addDays(context.calendarDays[0], index);
|
||
}
|
||
function periodBounds(state, context) {
|
||
const dates = [...new Set([...state.placements.keys(), ...context.declaredDates])].filter((date) => date >= context.horizon.start && date < context.horizon.end).sort(compareDate);
|
||
if (!dates.length)
|
||
return [];
|
||
const groups = [];
|
||
let group = [dates[0]];
|
||
for (let i = 1;i < dates.length; i++) {
|
||
context.check();
|
||
const previousIndex = context.calendarIndex.get(dates[i - 1]);
|
||
const currentIndex = context.calendarIndex.get(dates[i]);
|
||
const workingInGap = context.workingPrefix[currentIndex] - context.workingPrefix[previousIndex + 1];
|
||
if (workingInGap === 0)
|
||
group.push(dates[i]);
|
||
else {
|
||
groups.push(group);
|
||
group = [dates[i]];
|
||
}
|
||
}
|
||
groups.push(group);
|
||
return groups.map((anchors) => {
|
||
context.check();
|
||
let startIndex = context.calendarIndex.get(anchors[0]);
|
||
let endIndex = context.calendarIndex.get(anchors[anchors.length - 1]);
|
||
while (context.declaredDates.has(calendarDateAt(startIndex - 1, context)) || isNaturalNonWorkingDate(calendarDateAt(startIndex - 1, context), context)) {
|
||
context.check();
|
||
startIndex--;
|
||
}
|
||
while (context.declaredDates.has(calendarDateAt(endIndex + 1, context)) || isNaturalNonWorkingDate(calendarDateAt(endIndex + 1, context), context)) {
|
||
context.check();
|
||
endIndex++;
|
||
}
|
||
return { anchors, startIndex, endIndex };
|
||
});
|
||
}
|
||
function calendarPeriod(startIndex, endIndex, context) {
|
||
let periods = calendarPeriodCache.get(context);
|
||
if (!periods) {
|
||
periods = new Map;
|
||
calendarPeriodCache.set(context, periods);
|
||
}
|
||
const key = `${startIndex}:${endIndex}`;
|
||
let period = periods.get(key);
|
||
if (period)
|
||
periods.delete(key);
|
||
else {
|
||
const start = calendarDateAt(startIndex, context);
|
||
const end = calendarDateAt(endIndex, context);
|
||
const dates = startIndex >= 0 && endIndex < context.calendarDays.length ? context.calendarDays.slice(startIndex, endIndex + 1) : dateRange(start, addDays(end, 1));
|
||
period = Object.freeze({
|
||
start,
|
||
end,
|
||
duration: dates.length,
|
||
nonWorkingDates: Object.freeze(dates.filter((date) => isNaturalNonWorkingDate(date, context))),
|
||
declaredDates: Object.freeze(dates.filter((date) => context.declaredDates.has(date)))
|
||
});
|
||
}
|
||
periods.set(key, period);
|
||
if (periods.size > 4096)
|
||
periods.delete(periods.keys().next().value);
|
||
return period;
|
||
}
|
||
function periodData(state, context) {
|
||
return periodBounds(state, context).map(({ anchors, startIndex, endIndex }) => {
|
||
const period = calendarPeriod(startIndex, endIndex, context);
|
||
return {
|
||
start: period.start,
|
||
end: period.end,
|
||
duration: period.duration,
|
||
placementDates: anchors.filter((date) => state.placements.has(date)),
|
||
...period.declaredDates.length ? { declaredDates: [...period.declaredDates] } : {},
|
||
nonWorkingDates: [...period.nonWorkingDates],
|
||
nonWorkingDayGain: period.nonWorkingDates.length
|
||
};
|
||
});
|
||
}
|
||
function optimizationBalanceObservations(state, context) {
|
||
return state.balances.map((balance) => ({
|
||
unplacedQuantity: balance.remaining,
|
||
atRisk: isAtRisk(balance, context)
|
||
}));
|
||
}
|
||
function optimizationObservations(state, context, periods) {
|
||
const key = placementTieKey(state);
|
||
let byDates = calendarObservationCache.get(context);
|
||
if (!byDates) {
|
||
byDates = new Map;
|
||
calendarObservationCache.set(context, byDates);
|
||
}
|
||
const calendar = byDates.get(key) ?? {};
|
||
if (byDates.has(key))
|
||
byDates.delete(key);
|
||
else if (byDates.size >= 4096)
|
||
byDates.delete(byDates.keys().next().value);
|
||
byDates.set(key, calendar);
|
||
let bounds;
|
||
return {
|
||
leaveBalances: optimizationBalanceObservations(state, context),
|
||
get publicHolidayWeeks() {
|
||
return calendar.publicHolidayWeeks ??= Object.freeze(context.holidayWeeks.map((week) => Object.freeze({
|
||
value: week.value,
|
||
complete: week.dates.every((date) => state.placements.has(date) || context.declaredDates.has(date))
|
||
})));
|
||
},
|
||
get timeOffPeriods() {
|
||
return calendar.timeOffPeriods ??= Object.freeze(periods ? periods.map((period) => Object.freeze({
|
||
nonWorkingDates: Object.freeze([...period.nonWorkingDates])
|
||
})) : (bounds ??= periodBounds(state, context)).map(({ startIndex, endIndex }) => Object.freeze({
|
||
nonWorkingDates: calendarPeriod(startIndex, endIndex, context).nonWorkingDates
|
||
})));
|
||
},
|
||
get workSequences() {
|
||
return calendar.workSequences ??= Object.freeze(workSequenceLengths(bounds ??= periodBounds(state, context), context).map((sequence) => Object.freeze(sequence)));
|
||
},
|
||
leavePlacements: [...state.placements.values()]
|
||
};
|
||
}
|
||
function workSequenceLengths(bounds, context) {
|
||
if (!context.workingDays.length)
|
||
return [];
|
||
let nextIndex = context.calendarIndex.get(context.horizon.start);
|
||
const sequences = bounds.map(({ anchors }, index) => {
|
||
const previousIndex = nextIndex;
|
||
nextIndex = context.calendarIndex.get(anchors[anchors.length - 1]) + 1;
|
||
return {
|
||
length: context.workingPrefix[context.calendarIndex.get(anchors[0])] - context.workingPrefix[previousIndex],
|
||
internal: index > 0
|
||
};
|
||
});
|
||
sequences.push({
|
||
length: context.workingPrefix[context.calendarIndex.get(context.horizon.end)] - context.workingPrefix[nextIndex],
|
||
internal: false
|
||
});
|
||
return sequences;
|
||
}
|
||
function workSequenceDates(state, context) {
|
||
const sequences = [];
|
||
let current = [];
|
||
let inTimeOffPeriod = false;
|
||
for (const date of context.workingDays) {
|
||
context.check();
|
||
if (state.placements.has(date) || context.declaredDates.has(date)) {
|
||
if (!inTimeOffPeriod)
|
||
sequences.push(current);
|
||
current = [];
|
||
inTimeOffPeriod = true;
|
||
} else {
|
||
current.push(date);
|
||
inTimeOffPeriod = false;
|
||
}
|
||
}
|
||
if (context.workingDays.length)
|
||
sequences.push(current);
|
||
return sequences.map((dates, index) => ({
|
||
dates,
|
||
internal: index > 0 && index < sequences.length - 1
|
||
}));
|
||
}
|
||
function evaluateStateOptimization(configuration, state, context, observations = optimizationObservations(state, context)) {
|
||
return evaluateOptimization(configuration, observations);
|
||
}
|
||
function qualityMetrics(state, context, preferences) {
|
||
const periods = periodData(state, context);
|
||
const observations = optimizationObservations(state, context, periods);
|
||
const nonEmptySequences = observations.workSequences.filter((sequence) => sequence.length > 0);
|
||
return {
|
||
unplacedAtRisk: evaluateStateOptimization(OPTIMIZATION_PRESETS.unplacedAtRisk, state, context, observations),
|
||
holidayWeekValue: evaluateStateOptimization(OPTIMIZATION_PRESETS.holidayWeekValue, state, context, observations),
|
||
nonWorkingDayGain: evaluateStateOptimization(OPTIMIZATION_PRESETS.nonWorkingDayGain, state, context, observations),
|
||
longestWorkSequence: evaluateStateOptimization(OPTIMIZATION_PRESETS.longestWorkSequence, state, context, observations),
|
||
averageWorkSequence: nonEmptySequences.length ? nonEmptySequences.reduce((sum, sequence) => sum + sequence.length, 0) / nonEmptySequences.length : null,
|
||
averageTimeOffPeriod: periods.length ? periods.reduce((sum, period) => sum + period.duration, 0) / periods.length : null,
|
||
longestTimeOffPeriod: periods.length ? Math.max(...periods.map((period) => period.duration)) : null,
|
||
shortSequenceDeficit: evaluateStateOptimization(OPTIMIZATION_PRESETS.shortSequenceDeficit, state, context, observations),
|
||
supportingPlacements: evaluateStateOptimization(OPTIMIZATION_PRESETS.supportingPlacements, state, context, observations),
|
||
preferenceSatisfaction: preferences.map((preference) => preference.satisfied)
|
||
};
|
||
}
|
||
function nonPlacementReason(balance, state, context, completed) {
|
||
if (balance.expiryDate < context.horizon.start)
|
||
return reason("unavoidable-expiry", "This balance expired before the planning horizon.");
|
||
if (balance.availableFrom >= context.horizon.end)
|
||
return reason("available-after-horizon", "This balance becomes available after the last planning date.");
|
||
const dates = context.workingDays.filter((date) => date >= balance.availableFrom && date <= balance.expiryDate);
|
||
if (!dates.length)
|
||
return reason("no-working-date", "There is no working date within both the horizon and this balance’s validity period.");
|
||
if (dates.every((date) => context.declaredDates.has(date) || state.placements.has(date)))
|
||
return reason("all-dates-occupied", "Every working date within this balance’s validity period is already occupied in the displayed plan.");
|
||
if (!completed)
|
||
return reason("calculation-incomplete", "The calculation stopped before completing its planning priorities.");
|
||
if (balance.expiryDate > context.horizon.end)
|
||
return reason("preserved", "This balance expires after the horizon; the planner retained no additional placement under its planning priorities.");
|
||
return reason("active-priorities", "The calculation retained no additional placement under the active planning rules.");
|
||
}
|
||
function remainingBalances(state, context, completed) {
|
||
return state.balances.filter((balance) => balance.remaining > 0).map((balance) => {
|
||
const classification = compareDate(balance.expiryDate, context.horizon.start) < 0 ? "unavoidable-expiry" : compareDate(balance.expiryDate, context.horizon.end) <= 0 ? "at-risk" : "deferred";
|
||
return {
|
||
id: balance.id,
|
||
type: balance.type,
|
||
quantity: balance.remaining,
|
||
availableFrom: balance.availableFrom,
|
||
expiryDate: balance.expiryDate,
|
||
classification,
|
||
reason: nonPlacementReason(balance, state, context, completed),
|
||
earned: balance.earned,
|
||
sourceRuleId: balance.sourceRuleId
|
||
};
|
||
});
|
||
}
|
||
function unsatisfiedObligationCount(state, context) {
|
||
const placementCounts = new Map;
|
||
for (const placement of state.placements.values())
|
||
for (const ruleId of placement.ruleIds)
|
||
placementCounts.set(ruleId, (placementCounts.get(ruleId) ?? 0) + 1);
|
||
let unsatisfied = 0;
|
||
for (const requirement of buildRequirements(context.rules, context, "obligation")) {
|
||
if (!requirement.patterns) {
|
||
if ((placementCounts.get(requirement.rule.id) ?? 0) !== requirement.requiredPlacements)
|
||
unsatisfied++;
|
||
continue;
|
||
}
|
||
let complete = false;
|
||
for (const pattern of requirement.patterns) {
|
||
if (pattern.every((date) => patternDateSatisfied(date, requirement.rule, state, context))) {
|
||
complete = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!complete)
|
||
unsatisfied++;
|
||
}
|
||
return unsatisfied;
|
||
}
|
||
function objectiveVector(state, context, active = activeObjectiveVector(state, context)) {
|
||
return {
|
||
objectives: [
|
||
{
|
||
id: "obligation-validity",
|
||
direction: "minimize",
|
||
value: unsatisfiedObligationCount(state, context),
|
||
label: "Unsatisfied obligations"
|
||
},
|
||
...active,
|
||
...tieBreakObjectives(state)
|
||
]
|
||
};
|
||
}
|
||
function displayLabel(value, fallback) {
|
||
return typeof value === "string" && value.trim() ? value : fallback;
|
||
}
|
||
function timeWindowContributions(state, context) {
|
||
if (!context.declaredDays.length)
|
||
return [];
|
||
const labels = recordValue(context.request.labels);
|
||
const identities = recordValue(context.request.identities);
|
||
return context.rules.filter((rule) => rule.enabled && rule.type === "time_window").flatMap((rule) => {
|
||
const declaredDays = declaredWindowDays(rule, context);
|
||
return declaredDays.length ? [
|
||
{
|
||
ruleId: rule.id,
|
||
label: displayLabel(labels?.[rule.id] ?? identities?.[rule.id] ?? rule.name, rule.id),
|
||
requested: rule.placeDays,
|
||
declaredDays,
|
||
placementDates: [...state.placements.values()].filter((placement) => placement.ruleIds.has(rule.id)).map(({ date }) => date).sort(compareDate)
|
||
}
|
||
] : [];
|
||
});
|
||
}
|
||
function ifThenContributions(state, context) {
|
||
const labels = recordValue(context.request.labels);
|
||
const identities = recordValue(context.request.identities);
|
||
return context.rules.filter((rule) => rule.enabled && rule.type === "if_then").flatMap((rule) => occurrences(rule, context).flatMap((occurrence) => {
|
||
const id = `earned:${rule.id}:${occurrence}`;
|
||
const activation = state.earnedActivations.find((item) => item.id === id);
|
||
const pattern = selectedOccurrencePattern(rule, occurrence, state, context);
|
||
if (!pattern)
|
||
return [];
|
||
const declaredDays = pattern.flatMap((date) => {
|
||
const day = declaredPatternDay(date, rule.placeType, context);
|
||
return day ? [day] : [];
|
||
});
|
||
if (!declaredDays.length && !activation)
|
||
return [];
|
||
const bounds = activation ? earnedPeriodBounds(state, activation, context) : undefined;
|
||
return [
|
||
{
|
||
ruleId: rule.id,
|
||
label: displayLabel(labels?.[rule.id] ?? identities?.[rule.id] ?? rule.name, rule.id),
|
||
occurrence,
|
||
requested: rule.placeDays,
|
||
declaredDays,
|
||
placementDates: pattern.filter((date) => !context.declaredDates.has(date)),
|
||
...activation && bounds ? {
|
||
earnedEntitlement: {
|
||
id,
|
||
type: rule.rewardType,
|
||
quantity: rule.rewardDays,
|
||
...bounds,
|
||
added: bounds.availableFrom > context.request.calculationDate
|
||
}
|
||
} : {}
|
||
}
|
||
];
|
||
}));
|
||
}
|
||
function planExplanation(state, context, placements, periods, preferences, remaining, metrics) {
|
||
const source = context.request;
|
||
const rawBalances = Array.isArray(source.balances) ? source.balances : [];
|
||
const rawRules = Array.isArray(source.rules) ? source.rules : [];
|
||
const labels = recordValue(source.labels);
|
||
const identities = recordValue(source.identities);
|
||
const vector = objectiveVector(state, context);
|
||
const windowContributions = timeWindowContributions(state, context);
|
||
const patternContributions = ifThenContributions(state, context);
|
||
return {
|
||
kind: "PlanExplanation",
|
||
calculationDate: context.request.calculationDate,
|
||
...context.declaredDays.length ? { declaredDays: context.declaredDays } : {},
|
||
timeOffPeriods: periods,
|
||
...windowContributions.length ? { timeWindowContributions: windowContributions } : {},
|
||
...patternContributions.length ? { ifThenContributions: patternContributions } : {},
|
||
placements: placements.map((placement) => {
|
||
const balance = rawBalances.map(recordValue).find((candidate) => candidate?.id === placement.balanceId);
|
||
const normalizedBalance = state.balances.find((candidate) => candidate.id === placement.balanceId);
|
||
const period = periods.find((candidate) => candidate.placementDates.includes(placement.date));
|
||
const sourceRules = placement.ruleIds.map((id) => {
|
||
const rule = context.rules.find((candidate) => candidate.id === id);
|
||
const rawRule = rawRules.map(recordValue).find((candidate) => candidate?.id === id);
|
||
const label = displayLabel(labels?.[id] ?? identities?.[id] ?? rawRule?.name ?? rule?.name, id);
|
||
return { id, label };
|
||
});
|
||
const atRisk = normalizedBalance ? compareDate(normalizedBalance.expiryDate, context.horizon.start) >= 0 && compareDate(normalizedBalance.expiryDate, context.horizon.end) <= 0 : false;
|
||
const withoutPlacement = cloneState(state);
|
||
withoutPlacement.placements.delete(placement.date);
|
||
const released = withoutPlacement.balances.find((candidate) => candidate.id === placement.balanceId);
|
||
if (released)
|
||
released.remaining++;
|
||
const comparison = objectiveComparison(objectiveVector(withoutPlacement, context), vector);
|
||
const contributions = [
|
||
{
|
||
kind: "entitlement",
|
||
code: "balance",
|
||
label: displayLabel(labels?.[placement.balanceId] ?? identities?.[placement.balanceId] ?? balance?.label ?? balance?.name ?? balance?.id, placement.balanceId)
|
||
},
|
||
...sourceRules.map((rule) => ({
|
||
kind: "rule",
|
||
code: "rule",
|
||
label: rule.label,
|
||
ruleId: rule.id
|
||
}))
|
||
];
|
||
if (atRisk)
|
||
contributions.push({
|
||
kind: "at-risk",
|
||
code: "at-risk",
|
||
label: "Protects leave at risk of expiry."
|
||
});
|
||
if (placement.supporting)
|
||
contributions.push({
|
||
kind: "supporting",
|
||
code: "supporting",
|
||
label: "Supports the surrounding time-off plan."
|
||
});
|
||
if (period)
|
||
contributions.push({
|
||
kind: "time-off-period",
|
||
code: "time-off-period",
|
||
label: `Contributes to the time-off period ${period.start}–${period.end}.`,
|
||
dates: period.nonWorkingDates
|
||
});
|
||
for (const delta of comparison.delta) {
|
||
if (typeof delta.value !== "number" || delta.value === 0)
|
||
continue;
|
||
const objective = vector.objectives.find((candidate) => candidate.id === delta.id);
|
||
contributions.push({
|
||
kind: "metric",
|
||
code: objective.id,
|
||
label: objective.label ?? objective.id,
|
||
value: delta.value
|
||
});
|
||
}
|
||
const balanceSnapshot = balance ? {
|
||
id: typeof balance.id === "string" ? balance.id : placement.balanceId,
|
||
type: typeof balance.type === "string" ? balance.type : placement.type,
|
||
quantity: typeof balance.quantity === "number" ? balance.quantity : 0,
|
||
name: typeof balance.name === "string" ? balance.name : undefined,
|
||
label: typeof balance.label === "string" ? balance.label : undefined,
|
||
availableFrom: typeof balance.availableFrom === "string" || balance.availableFrom instanceof Date ? balance.availableFrom : normalizedBalance?.availableFrom,
|
||
expiryDate: typeof balance.expiryDate === "string" || balance.expiryDate instanceof Date ? balance.expiryDate : normalizedBalance?.expiryDate ?? ""
|
||
} : normalizedBalance ? {
|
||
id: normalizedBalance.id,
|
||
type: normalizedBalance.type,
|
||
quantity: normalizedBalance.quantity,
|
||
name: normalizedBalance.sourceRuleId ? `Earned from ${displayLabel(labels?.[normalizedBalance.sourceRuleId], normalizedBalance.sourceRuleId)}` : undefined,
|
||
availableFrom: normalizedBalance.availableFrom,
|
||
expiryDate: normalizedBalance.expiryDate
|
||
} : undefined;
|
||
return {
|
||
placement: { ...placement, ruleIds: [...placement.ruleIds] },
|
||
balance: balanceSnapshot,
|
||
ruleIds: [...placement.ruleIds],
|
||
supporting: placement.supporting,
|
||
timeOffPeriod: period,
|
||
remainingBalance: remaining.find((candidate) => candidate.id === placement.balanceId),
|
||
remainingQuantity: normalizedBalance?.remaining ?? 0,
|
||
contributions,
|
||
finalMetrics: metrics,
|
||
objectiveVector: vector,
|
||
comparison,
|
||
firstDecisiveObjective: comparison.firstDecisiveObjective
|
||
};
|
||
})
|
||
};
|
||
}
|
||
function makePlan(state, context, preferences, stages) {
|
||
const periods = periodData(state, context);
|
||
const metrics = qualityMetrics(state, context, preferences);
|
||
const placements = [...state.placements.values()].sort((a, b) => compareDate(a.date, b.date) || compareText(a.balanceId, b.balanceId)).map((placement) => ({
|
||
date: placement.date,
|
||
balanceId: placement.balanceId,
|
||
type: placement.type,
|
||
ruleIds: [...placement.ruleIds].sort(),
|
||
supporting: placement.supporting
|
||
}));
|
||
const remaining = remainingBalances(state, context, stages.includes("dates"));
|
||
const windowContributions = timeWindowContributions(state, context);
|
||
const patternContributions = ifThenContributions(state, context);
|
||
const plan = {
|
||
kind: "Plan",
|
||
calculationDate: context.request.calculationDate,
|
||
...context.declaredDays.length ? { declaredDays: context.declaredDays } : {},
|
||
...windowContributions.length ? { timeWindowContributions: windowContributions } : {},
|
||
...patternContributions.length ? { ifThenContributions: patternContributions } : {},
|
||
horizon: context.horizon,
|
||
placements,
|
||
timeOffPeriods: periods,
|
||
preferences,
|
||
remainingBalances: remaining,
|
||
metrics,
|
||
completedStages: [...stages],
|
||
lastCompletedStage: stages[stages.length - 1] ?? "validation"
|
||
};
|
||
context.retain?.(state);
|
||
return plan;
|
||
}
|
||
function markProgress(context, stage) {
|
||
if (typeof context.request.progress === "function")
|
||
observeCallback(context, () => context.request.progress(stage));
|
||
}
|
||
function ruleStage(rule) {
|
||
return `${rule.type === "optimization" ? "optimization" : "preference"}:${rule.id}`;
|
||
}
|
||
function planningStages(context) {
|
||
return [
|
||
"validation",
|
||
"obligations",
|
||
...context.rules.filter((rule) => rule.enabled && rule.force === "preference").map(ruleStage),
|
||
"expiry",
|
||
"dates"
|
||
];
|
||
}
|
||
function conflictExplanation(outcome, context) {
|
||
const labels = recordValue(context.request.labels);
|
||
return {
|
||
kind: "ConflictExplanation",
|
||
conflictingRules: outcome.conflictingRuleIds.map((id) => ({
|
||
id,
|
||
label: displayLabel(labels?.[id] ?? context.rules.find((rule) => rule.id === id)?.name, id)
|
||
})),
|
||
bottleneck: outcome.reasons[0]
|
||
};
|
||
}
|
||
function obligationConflict(requirements, context) {
|
||
const ruleIds = [...new Set(requirements.map((requirement) => requirement.rule.id))];
|
||
const generatedTypes = new Set(context.rules.filter((rule) => rule.enabled && rule.type === "if_then" && (rule.rewardDays ?? 0) > 0 && !!rule.rewardType).map((rule) => rule.rewardType));
|
||
let generatedCapacityBottleneck = false;
|
||
for (const requirement of requirements) {
|
||
if (requirement.rule.placeType === "any")
|
||
continue;
|
||
const required = requirement.requiredPlacements;
|
||
const capacity = context.initialBalances.filter((balance) => balance.type === requirement.rule.placeType).reduce((sum, balance) => sum + balance.quantity, 0);
|
||
if (capacity < required) {
|
||
if (!generatedTypes.has(requirement.rule.placeType))
|
||
return {
|
||
kind: "PlanningConflict",
|
||
conflictingRuleIds: ruleIds,
|
||
reasons: [
|
||
reason("typed-capacity", `The obligations require more ${requirement.rule.placeType.toUpperCase()} leave than is available.`, ruleIds)
|
||
]
|
||
};
|
||
generatedCapacityBottleneck = true;
|
||
}
|
||
}
|
||
if (requirements.some((requirement) => requirement.patterns !== undefined && requirement.patterns.length === 0 || requirement.candidates !== undefined && requirement.requiredPlacements > 0 && requirement.candidates.length === 0))
|
||
return {
|
||
kind: "PlanningConflict",
|
||
conflictingRuleIds: ruleIds,
|
||
reasons: [
|
||
reason("horizon-bottleneck", "The planning horizon contains no eligible dates for at least one obligation.", ruleIds)
|
||
]
|
||
};
|
||
if (generatedCapacityBottleneck)
|
||
return {
|
||
kind: "PlanningConflict",
|
||
conflictingRuleIds: ruleIds,
|
||
reasons: [
|
||
reason("earned-entitlement-bottleneck", "An earned leave entitlement is not available early enough to satisfy every obligation.", ruleIds)
|
||
]
|
||
};
|
||
return {
|
||
kind: "PlanningConflict",
|
||
conflictingRuleIds: ruleIds,
|
||
reasons: [
|
||
reason("joint-date-conflict", "The obligation date patterns cannot be satisfied together.", ruleIds)
|
||
]
|
||
};
|
||
}
|
||
function calculatePlanningInternal(request, checkpointCallback, artifactsCallback, outcomeCallback, explanationCallback) {
|
||
const steps = calculatePlanningSteps(request, checkpointCallback, artifactsCallback, outcomeCallback, explanationCallback);
|
||
let next = steps.next();
|
||
while (!next.done)
|
||
next = steps.next();
|
||
return next.value;
|
||
}
|
||
async function calculatePlanningAsyncInternal(request, checkpointCallback, artifactsCallback, outcomeCallback, explanationCallback, isCancelled = () => false) {
|
||
const steps = calculatePlanningSteps(request, checkpointCallback, artifactsCallback, outcomeCallback, explanationCallback, true);
|
||
let next = steps.next();
|
||
let pauseAt = now() + 8;
|
||
while (!next.done) {
|
||
if (next.value || now() >= pauseAt) {
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
pauseAt = now() + 8;
|
||
}
|
||
next = isCancelled() ? steps.throw(new UserCancelled) : steps.next();
|
||
}
|
||
return next.value;
|
||
}
|
||
function* prepareCalendar(horizon, progress) {
|
||
const start = addDays(horizon.start, -400);
|
||
const end = addDays(horizon.end, 400);
|
||
const holidays = new Set;
|
||
for (let year = Number(start.slice(0, 4));year <= Number(end.slice(0, 4)); year++) {
|
||
yield true;
|
||
for (const holiday of frenchPublicHolidaysForYear(year))
|
||
holidays.add(holiday);
|
||
progress();
|
||
}
|
||
const workingDays = [];
|
||
const calendarDays = [];
|
||
const calendarIndex = new Map;
|
||
const workingCalendar = new Set;
|
||
const workingPrefix = [0];
|
||
for (let date = start;compareDate(date, end) < 0; date = addDays(date, 1)) {
|
||
yield;
|
||
calendarIndex.set(date, calendarDays.length);
|
||
calendarDays.push(date);
|
||
const working = isWorking(date, holidays);
|
||
if (working) {
|
||
workingCalendar.add(date);
|
||
if (date >= horizon.start && date < horizon.end)
|
||
workingDays.push(date);
|
||
}
|
||
workingPrefix.push(workingPrefix[workingPrefix.length - 1] + Number(working));
|
||
}
|
||
return { holidays, workingDays, calendarDays, calendarIndex, workingCalendar, workingPrefix };
|
||
}
|
||
function* calculatePlanningSteps(request, checkpointCallback, artifactsCallback, outcomeCallback, explanationCallback, retainIncumbents = false) {
|
||
const source = runtimeRequest(request);
|
||
const normalized = normalizeRequest(source);
|
||
if (normalized.reasons.length) {
|
||
const outcome = { ...invalidInputFor(source), calculationDate: source.calculationDate };
|
||
outcomeCallback?.(outcome);
|
||
artifactsCallback?.({});
|
||
return outcome;
|
||
}
|
||
const horizon = normalized.horizon;
|
||
let calendar;
|
||
try {
|
||
if (typeof source.progress === "function")
|
||
source.progress("preparation");
|
||
yield true;
|
||
calendar = yield* prepareCalendar(horizon, () => {
|
||
if (typeof source.progress === "function")
|
||
source.progress("preparation");
|
||
});
|
||
} catch (error) {
|
||
if (!(error instanceof UserCancelled))
|
||
throw error;
|
||
const outcome = {
|
||
kind: "PlanningIncomplete",
|
||
calculationDate: source.calculationDate,
|
||
completedStages: ["validation"],
|
||
lastCompletedStage: "validation",
|
||
reasons: [reason("user-cancelled", "The calculation was cancelled by the user.")]
|
||
};
|
||
const explanation = {
|
||
kind: "IncompleteExplanation",
|
||
calculationDate: source.calculationDate,
|
||
reason: outcome.reasons[0],
|
||
completedStages: outcome.completedStages,
|
||
uncompletedStages: ["preparation", "obligations"]
|
||
};
|
||
outcomeCallback?.(outcome);
|
||
explanationCallback?.(explanation, undefined, undefined);
|
||
artifactsCallback?.({
|
||
explanation
|
||
});
|
||
return outcome;
|
||
}
|
||
const { holidays, workingDays, calendarDays, calendarIndex, workingCalendar, workingPrefix } = calendar;
|
||
const started = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
|
||
const deadline = typeof source.deadlineMs === "number" ? source.deadlineMs : Number.POSITIVE_INFINITY;
|
||
const context = {
|
||
horizon,
|
||
holidays,
|
||
holidayWeeks: [],
|
||
calendarDays,
|
||
calendarIndex,
|
||
workingCalendar,
|
||
workingPrefix,
|
||
workingDays,
|
||
declaredDays: normalized.declaredDays,
|
||
declaredDates: new Set(normalized.declaredDays.map(({ date }) => date)),
|
||
initialBalances: normalized.balances,
|
||
rules: normalized.rules,
|
||
deadline,
|
||
started,
|
||
request: source,
|
||
nodes: 0,
|
||
check: () => {
|
||
return;
|
||
},
|
||
reservedTypes: new Set,
|
||
sharedTypesByDate: new Map,
|
||
protectedTypesByDate: new Map,
|
||
preferenceDemandByDate: new Map,
|
||
anyPreferenceDemandByDate: new Map,
|
||
observerTime: 0,
|
||
completedPreferenceStates: new Map
|
||
};
|
||
context.holidayWeeks = holidayWeekCandidates(context);
|
||
context.check = () => {
|
||
context.nodes++;
|
||
if (context.deadline <= 1 || context.nodes % 16 === 0) {
|
||
if (now() - context.started - context.observerTime >= context.deadline)
|
||
throw new DeadlineReached;
|
||
}
|
||
};
|
||
const initialState = {
|
||
balances: normalized.balances.map((balance) => ({
|
||
...balance,
|
||
remaining: balance.quantity
|
||
})),
|
||
placements: new Map,
|
||
earnedActivations: []
|
||
};
|
||
const stages = ["validation"];
|
||
let state = initialState;
|
||
const preferences = [];
|
||
let checkpoint;
|
||
let checkpointState;
|
||
let retained;
|
||
if (retainIncumbents)
|
||
context.retain = (candidate, finalizedMetrics, candidateVector) => {
|
||
const check = context.check;
|
||
context.check = () => {
|
||
return;
|
||
};
|
||
try {
|
||
const finalized = finalizedMetrics || candidateVector ? candidate : finalizeEarnedState(candidate, context);
|
||
if (!finalized)
|
||
return;
|
||
if (unsatisfiedObligationCount(finalized, context))
|
||
return;
|
||
if (retained && preferenceStateKey(retained.state) === preferenceStateKey(finalized))
|
||
return;
|
||
const vector = candidateVector ?? objectiveVector(finalized, context);
|
||
const compared = retained ? compareObjectiveLists(vector.objectives, retained.vector.objectives) : -1;
|
||
const provenanceRefresh = compared === 0 && !!retained && JSON.stringify(retained.state.balances) === JSON.stringify(finalized.balances) && retained.state.placements.size === finalized.placements.size && [...retained.state.placements].every(([date, previous]) => {
|
||
const placement = finalized.placements.get(date);
|
||
return placement && placement.balanceId === previous.balanceId && placement.type === previous.type && placement.supporting === previous.supporting;
|
||
}) && JSON.stringify(retained.state.earnedActivations) === JSON.stringify(finalized.earnedActivations);
|
||
const chosen = compared < 0 || provenanceRefresh;
|
||
if (chosen) {
|
||
const firstValidCandidate = !retained;
|
||
const candidatePreferences = preferenceResultsForState(finalized, context);
|
||
retained = {
|
||
state: cloneState(reconcileOptimizationProvenance(finalized, context, retained?.state ?? initialState, vector.objectives)),
|
||
vector,
|
||
preferences: candidatePreferences,
|
||
metrics: finalizedMetrics ? {
|
||
...finalizedMetrics,
|
||
preferenceSatisfaction: candidatePreferences.map(({ satisfied }) => satisfied)
|
||
} : qualityMetrics(finalized, context, candidatePreferences)
|
||
};
|
||
if (firstValidCandidate && checkpointCallback)
|
||
observeCallback(context, () => checkpointCallback(makePlan(retained.state, context, retained.preferences, stages), planningStateSnapshot(retained.state, context)));
|
||
}
|
||
} finally {
|
||
context.check = check;
|
||
}
|
||
};
|
||
const finish = (outcome, explanationState) => {
|
||
outcome.calculationDate = source.calculationDate;
|
||
const planningFinishedAt = now();
|
||
const planningExcludedTime = context.observerTime;
|
||
outcomeCallback?.(outcome);
|
||
context.check = () => {
|
||
return;
|
||
};
|
||
let explanation;
|
||
let explanationError;
|
||
let finalState;
|
||
try {
|
||
if (outcome.kind === "Plan" && explanationState)
|
||
explanation = planExplanation(explanationState, context, outcome.placements, outcome.timeOffPeriods, outcome.preferences, outcome.remainingBalances, outcome.metrics);
|
||
else if (outcome.kind === "PlanningIncomplete") {
|
||
if (outcome.incumbent && explanationState) {
|
||
const incumbentExplanation = planExplanation(explanationState, context, outcome.incumbent.placements, outcome.incumbent.timeOffPeriods, outcome.incumbent.preferences, outcome.incumbent.remainingBalances, outcome.incumbent.metrics);
|
||
explanation = {
|
||
...incumbentExplanation,
|
||
incomplete: {
|
||
kind: "IncompleteExplanation",
|
||
reason: outcome.reasons[0],
|
||
completedStages: [...outcome.completedStages],
|
||
uncompletedStages: planningStages(context).filter((stage) => !outcome.completedStages.includes(stage))
|
||
}
|
||
};
|
||
} else
|
||
explanation = {
|
||
kind: "IncompleteExplanation",
|
||
reason: outcome.reasons[0],
|
||
completedStages: [...outcome.completedStages],
|
||
uncompletedStages: planningStages(context).filter((stage) => !outcome.completedStages.includes(stage))
|
||
};
|
||
} else if (outcome.kind === "PlanningConflict")
|
||
explanation = conflictExplanation(outcome, context);
|
||
} catch (error) {
|
||
explanationError = reason("explanation-error", error instanceof Error ? error.message : String(error));
|
||
}
|
||
try {
|
||
if (explanationState)
|
||
finalState = planningStateSnapshot(explanationState, context);
|
||
} catch (error) {
|
||
explanationError ??= reason("explanation-error", error instanceof Error ? error.message : String(error));
|
||
}
|
||
if (explanation)
|
||
explanation.calculationDate = source.calculationDate;
|
||
try {
|
||
explanationCallback?.(explanation, explanationError, finalState);
|
||
} catch (error) {
|
||
explanationError ??= reason("explanation-error", error instanceof Error ? error.message : String(error));
|
||
}
|
||
artifactsCallback?.({
|
||
explanation,
|
||
finalState,
|
||
explanationError,
|
||
timings: {
|
||
planningWorkMs: Math.max(0, planningFinishedAt - started - planningExcludedTime)
|
||
}
|
||
});
|
||
return outcome;
|
||
};
|
||
const publishCheckpoint = () => {
|
||
state = reconcileOptimizationProvenance(state, context, checkpointState ?? initialState);
|
||
context.retain?.(state);
|
||
checkpoint = makePlan(state, context, preferences, stages);
|
||
checkpointState = cloneState(state);
|
||
if (checkpointCallback) {
|
||
observeCallback(context, () => checkpointCallback(checkpoint, planningStateSnapshot(checkpointState, context)));
|
||
}
|
||
};
|
||
try {
|
||
markProgress(context, "validation");
|
||
yield true;
|
||
if (context.declaredDays.length) {
|
||
for (const rule of context.rules) {
|
||
if (!rule.enabled || rule.type !== "if_then" || !rule.rewardDays)
|
||
continue;
|
||
for (const occurrence of occurrences(rule, context)) {
|
||
yield;
|
||
const pattern = patternsFor(rule, occurrence, context).find((dates) => dates.every((date) => declaredPatternDay(date, rule.placeType, context)));
|
||
if (pattern)
|
||
state = addEarnedBalance(state, rule, occurrence, pattern, context);
|
||
}
|
||
}
|
||
if (state !== initialState)
|
||
context.retain?.(state);
|
||
}
|
||
context.protectedTypesByDate = futurePreferenceProtection(normalized.rules, 0, context);
|
||
markProgress(context, "obligations");
|
||
yield true;
|
||
const obligationRequirements = buildRequirements(normalized.rules, context, "obligation");
|
||
context.reservedTypes = new Set(obligationRequirements.filter((requirement) => requirement.requiredPlacements > 0).map((requirement) => requirement.rule.placeType).filter((selector) => selector !== "any"));
|
||
for (const requirement of obligationRequirements) {
|
||
yield;
|
||
if (!requirement.candidates || !requirement.requiredPlacements || requirement.candidates.length !== 1 || requirement.rule.placeType === "any")
|
||
continue;
|
||
const types = context.sharedTypesByDate.get(requirement.candidates[0]) ?? new Set;
|
||
types.add(requirement.rule.placeType);
|
||
context.sharedTypesByDate.set(requirement.candidates[0], types);
|
||
}
|
||
const obligationSolutions = [];
|
||
const optionalProducers = obligationRequirements.some((requirement) => requirement.requiredPlacements > 0) ? buildRequirements(normalized.rules, context, "preference").filter((requirement) => requirement.patterns?.length && requirement.rule.rewardDays && requirement.requiredPlacements > 0).map((requirement) => ({ ...requirement, optional: true })) : [];
|
||
const jointRequirements = optionalProducers.length ? [...obligationRequirements, ...optionalProducers].sort(compareRequirements) : obligationRequirements;
|
||
const hasEarnedObligation = optionalProducers.length > 0 || obligationRequirements.some((requirement) => (requirement.rule.rewardDays ?? 0) > 0);
|
||
const obligationSolutionLimit = hasEarnedObligation || obligationBranchEstimate(obligationRequirements) <= EXACT_OBLIGATION_BRANCH_LIMIT ? 0 : OBLIGATION_SOLUTION_LIMIT;
|
||
yield* satisfyObligations(jointRequirements, state, context, 0, obligationSolutions, obligationSolutionLimit);
|
||
if (!obligationSolutions.length) {
|
||
stages.push("obligations");
|
||
return finish(obligationConflict(obligationRequirements, context));
|
||
}
|
||
const preferenceRules = normalized.rules.filter((item) => item.enabled && item.force === "preference");
|
||
let previewSolutions = obligationSolutions;
|
||
if (obligationSolutionLimit > 0 && obligationRequirements.every((requirement) => requirement.rule.type === "time_window") && obligationSolutions.length > WINDOW_OBLIGATION_PREVIEW_LIMIT) {
|
||
const ranked = [];
|
||
for (const candidate of obligationSolutions) {
|
||
yield;
|
||
context.check();
|
||
ranked.push({
|
||
state: candidate,
|
||
objectives: obligationPreviewObjectives({ state: candidate }, context)
|
||
});
|
||
}
|
||
ranked.sort((a, b) => compareObjectiveLists(a.objectives, b.objectives));
|
||
previewSolutions = ranked.slice(0, WINDOW_OBLIGATION_PREVIEW_LIMIT).map(({ state: state2 }) => state2);
|
||
}
|
||
const soleSolution = obligationSolutions.length === 1 && (obligationSolutionLimit === 0 || obligationSolutions.length < obligationSolutionLimit) ? obligationSolutions[0] : undefined;
|
||
const solePreferences = soleSolution ? preferenceResultsForState(soleSolution, context) : [];
|
||
let bestPreview = soleSolution ? {
|
||
obligationState: soleSolution,
|
||
state: soleSolution,
|
||
preferences: solePreferences,
|
||
metrics: qualityMetrics(soleSolution, context, solePreferences)
|
||
} : null;
|
||
for (const obligationSolution of soleSolution ? [] : previewSolutions) {
|
||
yield;
|
||
context.check();
|
||
const preview = yield* applyPreferenceRules(cloneState(obligationSolution), preferenceRules, context);
|
||
const previewState = finalizeEarnedState(preview.state, context);
|
||
if (!previewState)
|
||
continue;
|
||
const candidate = {
|
||
obligationState: obligationSolution,
|
||
state: previewState,
|
||
preferences: preview.preferences,
|
||
metrics: qualityMetrics(previewState, context, preview.preferences)
|
||
};
|
||
const compared = bestPreview ? compareObligationPreviews(candidate, bestPreview, context) : undefined;
|
||
if (!bestPreview || compared < 0)
|
||
bestPreview = candidate;
|
||
}
|
||
if (!bestPreview) {
|
||
stages.push("obligations");
|
||
return finish(obligationConflict(obligationRequirements, context));
|
||
}
|
||
state = bestPreview.obligationState;
|
||
stages.push("obligations");
|
||
publishCheckpoint();
|
||
for (let preferenceIndex = 0;preferenceIndex < preferenceRules.length; preferenceIndex++) {
|
||
yield;
|
||
const rule = preferenceRules[preferenceIndex];
|
||
markProgress(context, ruleStage(rule));
|
||
yield true;
|
||
state = yield* applyPreferenceStep(state, preferenceRules, preferenceIndex, preferences, context);
|
||
stages.push(ruleStage(rule));
|
||
publishCheckpoint();
|
||
}
|
||
markProgress(context, "expiry");
|
||
yield true;
|
||
state = yield* optimizeRulePlacements(state, context, preferenceRules.length - 1, false);
|
||
stages.push("expiry");
|
||
publishCheckpoint();
|
||
markProgress(context, "dates");
|
||
yield true;
|
||
stages.push("dates");
|
||
const finalized = finalizeEarnedState(state, context);
|
||
if (!finalized) {
|
||
return finish({
|
||
kind: "PlanningConflict",
|
||
conflictingRuleIds: state.earnedActivations.map((activation) => activation.ruleId),
|
||
reasons: [
|
||
reason("earned-entitlement-order", "Generated leave became available only after its final merged time-off period.")
|
||
]
|
||
});
|
||
}
|
||
state = finalized;
|
||
publishCheckpoint();
|
||
markProgress(context, "complete");
|
||
yield true;
|
||
return finish(checkpoint, state);
|
||
} catch (error) {
|
||
if (error instanceof UserCancelled && retained) {
|
||
context.check = () => {
|
||
return;
|
||
};
|
||
context.retain = undefined;
|
||
checkpointState = retained.state;
|
||
const partialPreferences = retained.preferences.map((preference) => ({
|
||
...preference,
|
||
reason: preferenceReason(normalized.rules.find((rule) => rule.type !== "optimization" && rule.id === preference.ruleId), preference.satisfied, context, retained.state)
|
||
}));
|
||
checkpoint = makePlan(checkpointState, context, partialPreferences, stages);
|
||
}
|
||
const interruption = error instanceof UserCancelled ? reason("user-cancelled", "The calculation was cancelled by the user.") : error instanceof DeadlineReached ? reason("deadline", `Planning stopped after ${context.deadline}ms before all quality stages completed.`) : reason("planner-error", error instanceof Error ? error.message : String(error));
|
||
return finish({
|
||
kind: "PlanningIncomplete",
|
||
incumbent: checkpoint,
|
||
completedStages: [...stages],
|
||
lastCompletedStage: stages[stages.length - 1],
|
||
reasons: [interruption]
|
||
}, checkpointState);
|
||
}
|
||
}
|
||
function explainIncompleteCheckpoint(request, incumbent, checkpoint, interruption) {
|
||
try {
|
||
const source = runtimeRequest(request, incumbent.calculationDate ?? checkpoint.calculationDate);
|
||
const normalized = normalizeRequest(source);
|
||
if (normalized.reasons.length || !normalized.horizon)
|
||
throw new Error("The checkpoint explanation request is invalid.");
|
||
const horizon = normalized.horizon;
|
||
const holidays = holidaySet(horizon);
|
||
const calendarDays = dateRange(addDays(horizon.start, -400), addDays(horizon.end, 400));
|
||
const calendarIndex = new Map(calendarDays.map((date, index) => [date, index]));
|
||
const workingCalendar = new Set(calendarDays.filter((date) => isWorking(date, holidays)));
|
||
const workingPrefix = [0];
|
||
for (const date of calendarDays)
|
||
workingPrefix.push(workingPrefix[workingPrefix.length - 1] + Number(workingCalendar.has(date)));
|
||
const context = {
|
||
horizon,
|
||
holidayWeeks: [],
|
||
holidays,
|
||
calendarDays,
|
||
calendarIndex,
|
||
workingCalendar,
|
||
workingPrefix,
|
||
workingDays: dateRange(horizon.start, horizon.end).filter((date) => isWorking(date, holidays)),
|
||
declaredDays: normalized.declaredDays,
|
||
declaredDates: new Set(normalized.declaredDays.map(({ date }) => date)),
|
||
initialBalances: normalized.balances,
|
||
rules: normalized.rules,
|
||
deadline: Number.POSITIVE_INFINITY,
|
||
started: 0,
|
||
request: source,
|
||
nodes: 0,
|
||
check: () => {
|
||
return;
|
||
},
|
||
reservedTypes: new Set,
|
||
sharedTypesByDate: new Map,
|
||
protectedTypesByDate: new Map,
|
||
preferenceDemandByDate: new Map,
|
||
anyPreferenceDemandByDate: new Map,
|
||
observerTime: 0,
|
||
completedPreferenceStates: new Map
|
||
};
|
||
context.holidayWeeks = holidayWeekCandidates(context);
|
||
const state = {
|
||
balances: checkpoint.balances.map((balance) => ({ ...balance })),
|
||
placements: new Map(checkpoint.placements.map((placement) => [
|
||
placement.date,
|
||
{ ...placement, ruleIds: new Set(placement.ruleIds) }
|
||
])),
|
||
earnedActivations: checkpoint.earnedActivations.map((activation) => ({
|
||
...activation,
|
||
dates: [...activation.dates]
|
||
}))
|
||
};
|
||
const explanation = planExplanation(state, context, incumbent.placements, incumbent.timeOffPeriods, incumbent.preferences, incumbent.remainingBalances, incumbent.metrics);
|
||
const uncompletedStages = planningStages(context).filter((stage) => !incumbent.completedStages.includes(stage));
|
||
return {
|
||
explanation: uncompletedStages.length === 0 ? explanation : {
|
||
...explanation,
|
||
incomplete: {
|
||
kind: "IncompleteExplanation",
|
||
reason: interruption,
|
||
completedStages: [...incumbent.completedStages],
|
||
uncompletedStages
|
||
}
|
||
},
|
||
finalState: planningStateSnapshot(state, context)
|
||
};
|
||
} catch (error) {
|
||
return {
|
||
explanationError: reason("explanation-error", error instanceof Error ? error.message : String(error))
|
||
};
|
||
}
|
||
}
|
||
function counterfactualReason(code, message) {
|
||
return { code, message };
|
||
}
|
||
function counterfactualContext(source, normalized, horizon) {
|
||
const holidays = holidaySet(horizon);
|
||
const calendarDays = dateRange(addDays(horizon.start, -400), addDays(horizon.end, 400));
|
||
const calendarIndex = new Map(calendarDays.map((date, index) => [date, index]));
|
||
const workingCalendar = new Set(calendarDays.filter((date) => isWorking(date, holidays)));
|
||
const workingPrefix = [0];
|
||
for (const date of calendarDays)
|
||
workingPrefix.push(workingPrefix[workingPrefix.length - 1] + Number(workingCalendar.has(date)));
|
||
const context = {
|
||
horizon,
|
||
holidayWeeks: [],
|
||
holidays,
|
||
calendarDays,
|
||
calendarIndex,
|
||
workingCalendar,
|
||
workingPrefix,
|
||
workingDays: dateRange(horizon.start, horizon.end).filter((date) => isWorking(date, holidays)),
|
||
declaredDays: normalized.declaredDays,
|
||
declaredDates: new Set(normalized.declaredDays.map(({ date }) => date)),
|
||
initialBalances: normalized.balances,
|
||
rules: normalized.rules,
|
||
deadline: Number.POSITIVE_INFINITY,
|
||
started: 0,
|
||
request: source,
|
||
nodes: 0,
|
||
check: () => {
|
||
return;
|
||
},
|
||
reservedTypes: new Set,
|
||
sharedTypesByDate: new Map,
|
||
protectedTypesByDate: new Map,
|
||
preferenceDemandByDate: new Map,
|
||
anyPreferenceDemandByDate: new Map,
|
||
observerTime: 0,
|
||
completedPreferenceStates: new Map
|
||
};
|
||
context.holidayWeeks = holidayWeekCandidates(context);
|
||
return context;
|
||
}
|
||
function stateFromPlanningSnapshot(state) {
|
||
return {
|
||
balances: state.balances.map((balance) => ({ ...balance })),
|
||
placements: new Map(state.placements.map((placement) => [
|
||
placement.date,
|
||
{ ...placement, ruleIds: new Set(placement.ruleIds) }
|
||
])),
|
||
earnedActivations: state.earnedActivations.map((activation) => ({
|
||
...activation,
|
||
dates: [...activation.dates]
|
||
}))
|
||
};
|
||
}
|
||
function sameObjectiveValue(a, b) {
|
||
return a === b;
|
||
}
|
||
function objectiveComparison(before, after) {
|
||
const delta = after.objectives.map((objective, index) => {
|
||
const previous = before.objectives[index];
|
||
const value = typeof objective.value === "number" && typeof previous?.value === "number" ? objective.value - previous.value : sameObjectiveValue(objective.value, previous?.value ?? objective.value) ? 0 : null;
|
||
return {
|
||
id: objective.id,
|
||
direction: objective.direction,
|
||
value,
|
||
label: objective.label
|
||
};
|
||
});
|
||
const first = firstDifferentObjective(after.objectives, before.objectives);
|
||
const decisive = first >= 0 ? after.objectives[first].id : undefined;
|
||
return {
|
||
before,
|
||
after,
|
||
delta,
|
||
firstDecisiveObjective: decisive,
|
||
tieBreak: decisive === "balance-expiry" ? "balance-expiry" : decisive === "placement-date" ? "placement-date" : undefined
|
||
};
|
||
}
|
||
function counterfactualRuleValid(date, type, ruleIds, context, baseline) {
|
||
for (const ruleId of ruleIds) {
|
||
const rule = context.rules.find((candidate) => candidate.id === ruleId);
|
||
if (!rule)
|
||
return false;
|
||
if (rule.type === "optimization")
|
||
continue;
|
||
if (rule.type === "time_window") {
|
||
if (!selectorMatches(rule.placeType, type) || compareDate(date, rule.startDate) < 0 || compareDate(date, rule.endDate) > 0)
|
||
return false;
|
||
continue;
|
||
}
|
||
const matchesPattern = occurrences(rule, context).some((occurrence) => patternsFor(rule, occurrence, context).some((pattern) => pattern.includes(date) && pattern.every((candidateDate) => candidateDate === date || patternDateSatisfied(candidateDate, rule, baseline, context))));
|
||
if (!matchesPattern || !selectorMatches(rule.placeType, type))
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
function counterfactualObligationsValid(state, context, previous) {
|
||
return context.rules.filter((rule) => rule.enabled && rule.force === "obligation").every((rule) => {
|
||
if (rule.type === "time_window") {
|
||
const count = (candidate) => [...candidate.placements.values()].filter((placement) => placement.ruleIds.has(rule.id)).length;
|
||
const requiredPlacements = rule.placeDays - declaredWindowDays(rule, context).length;
|
||
return count(previous) !== requiredPlacements || count(state) === requiredPlacements;
|
||
}
|
||
return occurrences(rule, context).every((occurrence) => {
|
||
const patterns = patternsFor(rule, occurrence, context);
|
||
const complete = (candidate) => patterns.some((pattern) => pattern.every((date) => patternDateSatisfied(date, rule, candidate, context)));
|
||
return !complete(previous) || complete(state);
|
||
});
|
||
});
|
||
}
|
||
function preferenceResultsForState(state, context) {
|
||
let patternsByRule = preferencePatternCache.get(context);
|
||
if (!patternsByRule) {
|
||
patternsByRule = new Map(context.rules.filter((rule) => rule.enabled && rule.force === "preference" && rule.type === "if_then").map((rule) => [
|
||
rule.id,
|
||
occurrences(rule, context).map((occurrence) => patternsFor(rule, occurrence, context))
|
||
]));
|
||
preferencePatternCache.set(context, patternsByRule);
|
||
}
|
||
return context.rules.filter((rule) => rule.enabled && rule.force === "preference" && rule.type !== "optimization").map((rule) => {
|
||
const occurrencePatterns = patternsByRule.get(rule.id) ?? [];
|
||
const requested = rule.type === "time_window" ? rule.placeDays : occurrencePatterns.length;
|
||
const satisfied = rule.type === "time_window" ? Math.min(rule.placeDays, declaredWindowDays(rule, context).length + [...state.placements.values()].filter((placement) => placement.date >= rule.startDate && placement.date <= rule.endDate && selectorMatches(rule.placeType, placement.type)).length) : occurrencePatterns.filter((patterns) => patterns.some((pattern) => pattern.every((date) => patternDateSatisfied(date, rule, state, context)))).length;
|
||
return {
|
||
ruleId: rule.id,
|
||
requested,
|
||
satisfied,
|
||
completeOccurrences: rule.type === "if_then" ? satisfied : 0
|
||
};
|
||
});
|
||
}
|
||
function analyzeCounterfactualInternal(request, plan, selected, finalStateSnapshot) {
|
||
const source = runtimeRequest(request, plan.calculationDate ?? finalStateSnapshot?.calculationDate);
|
||
const normalized = normalizeRequest(source);
|
||
const horizon = normalized.horizon ?? plan.horizon;
|
||
const context = counterfactualContext(source, normalized, horizon);
|
||
const finalState = finalStateSnapshot ? stateFromPlanningSnapshot(finalStateSnapshot) : (() => {
|
||
const balances = normalized.balances.map((balance) => ({
|
||
...balance,
|
||
remaining: balance.quantity
|
||
}));
|
||
for (const placement of plan.placements) {
|
||
let balance = balances.find((candidate) => candidate.id === placement.balanceId);
|
||
if (!balance) {
|
||
const remaining = plan.remainingBalances.find((candidate) => candidate.id === placement.balanceId);
|
||
balance = {
|
||
id: placement.balanceId,
|
||
type: placement.type,
|
||
quantity: 0,
|
||
remaining: 0,
|
||
availableFrom: remaining?.availableFrom ?? horizon.start,
|
||
expiryDate: remaining?.expiryDate ?? horizon.end,
|
||
earned: remaining?.earned ?? true,
|
||
sourceRuleId: remaining?.sourceRuleId
|
||
};
|
||
balances.push(balance);
|
||
}
|
||
balance.remaining = Math.max(0, balance.remaining - 1);
|
||
}
|
||
return {
|
||
balances,
|
||
placements: new Map(plan.placements.map((placement) => [
|
||
placement.date,
|
||
{ ...placement, ruleIds: new Set(placement.ruleIds) }
|
||
])),
|
||
earnedActivations: []
|
||
};
|
||
})();
|
||
const comparisonState = cloneState(finalState);
|
||
const baseline = cloneState(finalState);
|
||
const removeDate = selected.date;
|
||
const removed = removeDate ? baseline.placements.get(removeDate) : undefined;
|
||
if (removeDate)
|
||
baseline.placements.delete(removeDate);
|
||
const released = baseline.balances.find((balance) => balance.id === selected.balanceId);
|
||
if (released && removed?.balanceId === selected.balanceId)
|
||
released.remaining++;
|
||
const beforeState = baseline;
|
||
const before = objectiveVector(beforeState, context);
|
||
const results = [];
|
||
for (const date of dateRange(horizon.start, horizon.end)) {
|
||
let ineligible;
|
||
if (!isWorking(date, context.holidays))
|
||
ineligible = counterfactualReason("non-working", "The date is a weekend or public holiday.");
|
||
else if (context.declaredDates.has(date))
|
||
ineligible = counterfactualReason("declared-day", "The date is a declared non-working day fixed by the user.");
|
||
else if (baseline.placements.has(date))
|
||
ineligible = counterfactualReason("occupied", "Another final placement already uses this date.");
|
||
else if (!released)
|
||
ineligible = counterfactualReason("unavailable", "The selected leave entitlement is unavailable.");
|
||
else if (compareDate(released.availableFrom, date) > 0)
|
||
ineligible = counterfactualReason("unavailable", "The selected entitlement is not available yet.");
|
||
else if (compareDate(date, released.expiryDate) > 0)
|
||
ineligible = counterfactualReason("expired", "The selected entitlement has expired by this date.");
|
||
else if (released.type !== selected.type)
|
||
ineligible = counterfactualReason("type-incompatible", "The date cannot host this leave type.");
|
||
else if (!counterfactualRuleValid(date, selected.type, selected.ruleIds, context, baseline))
|
||
ineligible = counterfactualReason("rule-invalid", "The date does not preserve the placement rules.");
|
||
if (ineligible) {
|
||
results.push({ date, status: "ineligible", reason: ineligible });
|
||
continue;
|
||
}
|
||
const candidate = assignDateToBalance(baseline, date, selected.balanceId, context, new Set(selected.ruleIds));
|
||
if (!candidate) {
|
||
results.push({
|
||
date,
|
||
status: "ineligible",
|
||
reason: counterfactualReason("unavailable", "The selected entitlement cannot be placed on this date.")
|
||
});
|
||
continue;
|
||
}
|
||
candidate.placements.get(date).supporting = selected.supporting;
|
||
if (removeDate && removeDate !== date)
|
||
for (const activation of candidate.earnedActivations) {
|
||
if (!selected.ruleIds.includes(activation.ruleId))
|
||
continue;
|
||
activation.dates = activation.dates.map((activationDate) => activationDate === removeDate ? date : activationDate);
|
||
}
|
||
const finalized = finalizeEarnedState(candidate, context);
|
||
if (!finalized) {
|
||
results.push({
|
||
date,
|
||
status: "ineligible",
|
||
reason: counterfactualReason("unavailable", "This date would make generated leave unavailable until its producing period ends.")
|
||
});
|
||
continue;
|
||
}
|
||
if (!counterfactualObligationsValid(finalized, context, comparisonState)) {
|
||
results.push({
|
||
date,
|
||
status: "ineligible",
|
||
reason: counterfactualReason("rule-invalid", "The date would leave an obligation unsatisfied.")
|
||
});
|
||
continue;
|
||
}
|
||
const after = objectiveVector(finalized, context);
|
||
const comparison = objectiveComparison(before, after);
|
||
results.push({ date, status: "eligible", comparison });
|
||
}
|
||
return {
|
||
kind: "Counterfactual",
|
||
calculationId: "",
|
||
placement: { ...selected, ruleIds: [...selected.ruleIds] },
|
||
hypothetical: true,
|
||
baseline: before,
|
||
results
|
||
};
|
||
}
|
||
export {
|
||
invalidInputFor,
|
||
explainIncompleteCheckpoint,
|
||
calculatePlanningInternal,
|
||
calculatePlanningAsyncInternal,
|
||
analyzeCounterfactualInternal
|
||
};
|