@tmlmobilidade/dates 20260612.1126.8 → 20260612.1446.12

package/dist/calendar/rules/calculation/index.d.ts

@@ -1,5 +1,21 @@
-import type { RuleApplication } from './types.js';
-import type { Event, Holiday, OperationalDate, ScheduleRule, YearPeriod } from '@tmlmobilidade/types';
+import type { DayContext, RuleApplication } from './types.js';
+import type { Event, EventReplacementRule, EventRestrictionRule, Holiday, ManualRule, OperationalDate, ScheduleRule, YearPeriod } from '@tmlmobilidade/types';
+export interface ComputeActiveRulesOptions {
+    dateContext?: ActiveRulesDateContext;
+    eventById?: Map<string, Event>;
+    events?: Event[];
+}
+export interface ActiveRulesDateContext extends DayContext {
+    key: string;
+}
+export interface SplitScheduleRules {
+    manualRules: ManualRule[];
+    replacementRules: EventReplacementRule[];
+    restrictionRules: EventRestrictionRule[];
+}
+export declare function buildActiveRulesEventIndex(events?: Event[]): Map<string, Event>;
+export declare function buildActiveRulesDateContext(date: OperationalDate, periods: YearPeriod[], holidays: Holiday[]): ActiveRulesDateContext;
+export declare function splitScheduleRules(rules: ScheduleRule[]): SplitScheduleRules;
 /**
  * Operating schedule for one operational date: merged timepoints and applied rule IDs.
  *
@@ -25,6 +41,6 @@ import type { Event, Holiday, OperationalDate, ScheduleRule, YearPeriod } from '
  * @param holidays - Holiday calendar for weekday resolution
  * @returns Active timepoints and IDs of rules that contributed
  */
-export declare function computeActiveRules(date: OperationalDate, rules: ScheduleRule[], periods: YearPeriod[], holidays: Holiday[], options?: {
-    events?: Event[];
-}): RuleApplication;
+export declare function computeActiveRules(date: OperationalDate, rules: ScheduleRule[], periods: YearPeriod[], holidays: Holiday[], options?: ComputeActiveRulesOptions): RuleApplication;
+export declare function computeActiveRulesFromSplit(date: OperationalDate, rules: SplitScheduleRules, periods: YearPeriod[], holidays: Holiday[], options?: ComputeActiveRulesOptions): RuleApplication;
+export declare function computeActiveRuleCountFromSplit(date: OperationalDate, rules: SplitScheduleRules, periods: YearPeriod[], holidays: Holiday[], options?: ComputeActiveRulesOptions): number;

package/dist/calendar/rules/calculation/index.js

@@ -4,7 +4,95 @@ import { resolveEffectiveReplacement } from '../export-attribution/replacement.j
 import { findReplacementForDate, getActivePeriodId } from '../utils/date.js';
 import { collectManualIncludes, collectReplacementManualIncludes } from './collectors.js';
 import { applyEventRestrictions, applyManualExcludes, applyReplacementManualExcludes } from './filters.js';
-/* * */
+import { getTimepointsRemovedByEventRestriction } from './filters.js';
+import { manualRuleMatchesContext, manualRuleMatchesReplacement } from './matchers.js';
+export function buildActiveRulesEventIndex(events = []) {
+    return new Map(events.map(event => [event._id, event]));
+}
+export function buildActiveRulesDateContext(date, periods, holidays) {
+    const key = calendarKey(Dates.fromOperationalDate(date, 'Europe/Lisbon'));
+    return {
+        key,
+        weekday: calendarWeekday(key, holidays),
+        yearPeriodId: getActivePeriodId(date, periods),
+    };
+}
+export function splitScheduleRules(rules) {
+    return {
+        manualRules: rules.filter((r) => r.kind === 'manual'),
+        replacementRules: rules.filter((r) => r.kind === 'event_replacement'),
+        restrictionRules: rules.filter((r) => r.kind === 'event_restriction'),
+    };
+}
+function resolveEventById(id, options) {
+    return options?.eventById?.get(id) ?? options?.events?.find(event => event._id === id);
+}
+function filterManualRulesByEventDate(manualRules, date, options) {
+    return manualRules.filter((rule) => {
+        if (!rule.event_id)
+            return true;
+        const event = resolveEventById(rule.event_id, options);
+        if (!event?.dates?.length)
+            return false;
+        return event.dates.includes(date);
+    });
+}
+function filterManualRulesByMonth(manualRules, month) {
+    return manualRules.filter(rule => !rule.months?.length || rule.months.includes(month));
+}
+function collectManualIncludeTimepoints(manualRules, ctx) {
+    const timepoints = new Set();
+    for (const rule of manualRules) {
+        if (rule.operating_mode !== 'include')
+            continue;
+        if (!manualRuleMatchesContext(rule, ctx))
+            continue;
+        for (const timepoint of rule.timepoints ?? [])
+            timepoints.add(timepoint);
+    }
+    return timepoints;
+}
+function collectReplacementManualIncludeTimepoints(replacement, manualRules) {
+    const timepoints = new Set();
+    for (const rule of manualRules) {
+        if (rule.operating_mode !== 'include')
+            continue;
+        if (!manualRuleMatchesReplacement(rule, replacement))
+            continue;
+        for (const timepoint of rule.timepoints)
+            timepoints.add(timepoint);
+    }
+    return timepoints;
+}
+function applyManualExcludeTimepoints(timepoints, manualRules, ctx) {
+    for (const rule of manualRules) {
+        if (rule.operating_mode !== 'exclude')
+            continue;
+        if (!manualRuleMatchesContext(rule, ctx))
+            continue;
+        for (const timepoint of rule.timepoints ?? [])
+            timepoints.delete(timepoint);
+    }
+}
+function applyReplacementManualExcludeTimepoints(timepoints, replacement, manualRules) {
+    for (const rule of manualRules) {
+        if (rule.operating_mode !== 'exclude')
+            continue;
+        if (!manualRuleMatchesReplacement(rule, replacement))
+            continue;
+        for (const timepoint of rule.timepoints)
+            timepoints.delete(timepoint);
+    }
+}
+function applyEventRestrictionTimepoints(date, timepoints, rules) {
+    for (const rule of rules) {
+        if (!rule.dates?.includes(date))
+            continue;
+        for (const timepoint of getTimepointsRemovedByEventRestriction(rule, timepoints)) {
+            timepoints.delete(timepoint);
+        }
+    }
+}
 /**
  * Operating schedule for one operational date: merged timepoints and applied rule IDs.
  *
@@ -31,21 +119,16 @@ import { applyEventRestrictions, applyManualExcludes, applyReplacementManualExcl
  * @returns Active timepoints and IDs of rules that contributed
  */
 export function computeActiveRules(date, rules, periods, holidays, options) {
-    const manualRules = rules.filter((r) => r.kind === 'manual');
-    const restrictionRules = rules.filter(r => r.kind === 'event_restriction');
-    const replacementRules = rules.filter((r) => r.kind === 'event_replacement');
-    const filteredManualRules = manualRules.filter((rule) => {
-        if (!rule.event_id)
-            return true;
-        const event = options?.events?.find(e => e._id === rule.event_id);
-        if (!event?.dates?.length)
-            return false;
-        return event.dates.includes(date);
-    });
-    const key = calendarKey(Dates.fromOperationalDate(date, 'Europe/Lisbon'));
+    const splitRules = splitScheduleRules(rules);
+    return computeActiveRulesFromSplit(date, splitRules, periods, holidays, options);
+}
+export function computeActiveRulesFromSplit(date, rules, periods, holidays, options) {
+    const { manualRules, replacementRules, restrictionRules } = rules;
+    const filteredManualRules = filterManualRulesByEventDate(manualRules, date, options);
+    const key = options?.dateContext?.key ?? calendarKey(Dates.fromOperationalDate(date, 'Europe/Lisbon'));
     // Filter out manual rules whose months list doesn't include the current month
     const month = Number(key.slice(5, 7));
-    const monthFilteredManualRules = filteredManualRules.filter(rule => !rule.months?.length || rule.months.includes(month));
+    const monthFilteredManualRules = filterManualRulesByMonth(filteredManualRules, month);
     const replacement = findReplacementForDate(date, replacementRules);
     // 1) Base timepoints
     let timepoints;
@@ -61,10 +144,7 @@ export function computeActiveRules(date, rules, periods, holidays, options) {
     }
     else {
         // Normal mode: day resolves to a single weekday + single yearPeriodId
-        const ctx = {
-            weekday: calendarWeekday(key, holidays),
-            yearPeriodId: getActivePeriodId(date, periods),
-        };
+        const ctx = options?.dateContext ?? buildActiveRulesDateContext(date, periods, holidays);
         const base = collectManualIncludes(monthFilteredManualRules, ctx);
         timepoints = base.timepoints;
         appliedRuleIds = base.appliedRuleIds;
@@ -78,4 +158,24 @@ export function computeActiveRules(date, rules, periods, holidays, options) {
     };
     return result;
 }
+export function computeActiveRuleCountFromSplit(date, rules, periods, holidays, options) {
+    const filteredManualRules = filterManualRulesByEventDate(rules.manualRules, date, options);
+    const key = options?.dateContext?.key ?? calendarKey(Dates.fromOperationalDate(date, 'Europe/Lisbon'));
+    const month = Number(key.slice(5, 7));
+    const monthFilteredManualRules = filterManualRulesByMonth(filteredManualRules, month);
+    const replacement = findReplacementForDate(date, rules.replacementRules);
+    let timepoints;
+    if (replacement) {
+        const effectiveReplacement = resolveEffectiveReplacement(date, replacement, holidays);
+        timepoints = collectReplacementManualIncludeTimepoints(effectiveReplacement, monthFilteredManualRules);
+        applyReplacementManualExcludeTimepoints(timepoints, effectiveReplacement, monthFilteredManualRules);
+    }
+    else {
+        const ctx = options?.dateContext ?? buildActiveRulesDateContext(date, periods, holidays);
+        timepoints = collectManualIncludeTimepoints(monthFilteredManualRules, ctx);
+        applyManualExcludeTimepoints(timepoints, monthFilteredManualRules, ctx);
+    }
+    applyEventRestrictionTimepoints(date, timepoints, rules.restrictionRules);
+    return timepoints.size;
+}
 /* * */

package/dist/vkm.js

@@ -1,7 +1,7 @@
 import { buildOperationalDateRange } from './calendar/rules/utils/date.js';
 import { calendarWeekday } from './calendar/utils/index.js';
 import { Dates } from './dates.js';
-import { computeActiveRules } from './calendar/rules/calculation/index.js';
+import { buildActiveRulesDateContext, buildActiveRulesEventIndex, computeActiveRuleCountFromSplit, splitScheduleRules } from './calendar/rules/calculation/index.js';
 import { resolvePatternRules } from './calendar/rules/merging/index.js';
 const UNASSIGNED_PERIOD_KEY = '__unassigned__';
 const UNASSIGNED_PERIOD_NAME = 'Sem período definido';
@@ -119,7 +119,11 @@ function buildCalculationContext(request, holidays, periods) {
     const { endDate, startDate } = resolveCalculationEndDate(request);
     const operationalDates = buildOperationalDateRange(startDate.js_date, endDate.js_date);
     const { metadataByDate, relevantPeriods } = buildDayMetadata(operationalDates, holidays, periods);
-    return { endDate, metadataByDate, operationalDates, relevantPeriods };
+    const activeRulesContextByDate = new Map();
+    for (const date of operationalDates) {
+        activeRulesContextByDate.set(date, buildActiveRulesDateContext(date, periods, holidays));
+    }
+    return { activeRulesContextByDate, endDate, metadataByDate, operationalDates, relevantPeriods };
 }
 function buildCalculationInputs(agency, request, endDate) {
     const totalVkmPerYear = agency.financials.vkm_per_month.reduce((sum, value) => sum + Number(value ?? 0), 0);
@@ -141,8 +145,9 @@ export function getPatternExtensionMeters(pattern, source) {
     return Number(pattern.shape?.extension ?? 0);
 }
 export function calculateAgencyVkm({ agency, events, holidays, patterns, periods, request }) {
-    const { endDate, metadataByDate, operationalDates, relevantPeriods } = buildCalculationContext(request, holidays, periods);
+    const { activeRulesContextByDate, endDate, metadataByDate, operationalDates, relevantPeriods } = buildCalculationContext(request, holidays, periods);
     const accumulator = createAccumulator(relevantPeriods);
+    const eventById = buildActiveRulesEventIndex(events);
     for (const pattern of patterns) {
         const extensionMeters = getPatternExtensionMeters(pattern, request.extension_source);
         if (!extensionMeters)
@@ -150,9 +155,16 @@ export function calculateAgencyVkm({ agency, events, holidays, patterns, periods
         const mergedRules = resolvePatternRules(pattern, events);
         if (!mergedRules.length)
             continue;
+        const splitRules = splitScheduleRules(mergedRules);
         for (const date of operationalDates) {
-            const activeRules = computeActiveRules(date, mergedRules, periods, holidays, { events });
-            const activeTripCount = activeRules.timepoints.length;
+            const dateContext = activeRulesContextByDate.get(date);
+            if (!dateContext)
+                continue;
+            const activeTripCount = computeActiveRuleCountFromSplit(date, splitRules, periods, holidays, {
+                dateContext,
+                eventById,
+                events,
+            });
             if (!activeTripCount)
                 continue;
             const dayMetadata = metadataByDate.get(date);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tmlmobilidade/dates",
-	"version": "20260612.1126.8",
+	"version": "20260612.1446.12",
 	"author": {
 		"email": "iso@tmlmobilidade.pt",
 		"name": "TML-ISO"