@tmlmobilidade/dates 20260329.1522.22 → 20260330.1735.58

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

@@ -1,5 +1,5 @@
 import type { RuleApplication } from './types.js';
-import type { Event, OperationalDate, ScheduleRule, YearPeriod } from '@tmlmobilidade/types';
+import type { Event, Holiday, OperationalDate, ScheduleRule, YearPeriod } from '@tmlmobilidade/types';
 /**
  * Calculates which time points are active for each date in a range, based on scheduling rules.
  *
@@ -36,6 +36,6 @@ import type { Event, OperationalDate, ScheduleRule, YearPeriod } from '@tmlmobil
  * // }
  * ```
  */
-export declare function computeActiveRules(date: OperationalDate, rules: ScheduleRule[], periods: YearPeriod[], options?: {
+export declare function computeActiveRules(date: OperationalDate, rules: ScheduleRule[], periods: YearPeriod[], holidays: Holiday[], options?: {
     events?: Event[];
 }): RuleApplication;

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

@@ -40,7 +40,7 @@ import { applyEventRestrictions, applyManualExcludes, applyReplacementManualExcl
  * // }
  * ```
  */
-export function computeActiveRules(date, rules, periods, options) {
+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');
@@ -61,7 +61,7 @@ export function computeActiveRules(date, rules, periods, options) {
         // When same_weekday is true, each event date functions as its own actual weekday
         // within the replacement's target periods, rather than all dates acting as one fixed weekday.
         const effectiveReplacement = replacement.same_weekday
-            ? { ...replacement, weekdays: [calendarWeekday(key)] }
+            ? { ...replacement, weekdays: [calendarWeekday(key, holidays)] }
             : replacement;
         // Replacement mode: match manuals by intersection (Option A)
         const base = collectReplacementManualIncludes(effectiveReplacement, filteredManualRules);
@@ -73,7 +73,7 @@ export function computeActiveRules(date, rules, periods, options) {
     else {
         // Normal mode: day resolves to a single weekday + single yearPeriodId
         const ctx = {
-            weekday: calendarWeekday(key),
+            weekday: calendarWeekday(key, holidays),
             yearPeriodId: getActivePeriodId(date, periods),
         };
         const base = collectManualIncludes(filteredManualRules, ctx);

package/dist/calendar/rules/formatting/rule-summary.d.ts

@@ -38,3 +38,17 @@ export declare function buildRuleSummary(rule: ScheduleRule, options: {
     events?: Event[];
     periods?: YearPeriod[];
 }): RuleSummary;
+/**
+ * GTFS-oriented rule token:
+ * - FER_DU
+ * - VER_SAB
+ * - ESC_DOM
+ * - ALL
+ * - ALL_DU
+ * - VER-FER_SAB-DOM
+ * - event title for event rules (temporary)
+ */
+export declare function buildRuleSummaryGtfs(rule: ScheduleRule, options: {
+    events?: Event[];
+    periods?: YearPeriod[];
+}): string;

package/dist/calendar/rules/formatting/rule-summary.js

@@ -175,3 +175,83 @@ function buildRuleSummaryTooltip(rule, options) {
     }
     return '';
 }
+/**
+ * TEMP:
+ * Maps year period ids/names into GTFS abbreviations.
+ * Replace with a persisted abbreviation/code field when available.
+ */
+function mapPeriodsToGtfsAbbreviation(periodIds) {
+    if (!periodIds?.length)
+        return 'ALL';
+    const map = {
+        '2KIUJ': 'FER',
+        '99H2R': 'ESC',
+        'UW2U0': 'VER',
+    };
+    const abbreviations = periodIds.map((id) => {
+        const abbr = map[id];
+        if (!abbr)
+            throw new Error(`Unknown period id: ${id}`);
+        return abbr;
+    });
+    const unique = [...new Set(abbreviations)];
+    const allSet = new Set(['ESC', 'FER', 'VER']);
+    // If all three are present, return 'ALL'
+    if (unique.length === 3 && unique.every(x => allSet.has(x))) {
+        return 'ALL';
+    }
+    return unique.join('-');
+}
+function mapWeekdaysToGtfsAbbreviation(weekdays) {
+    if (!weekdays?.length)
+        return 'ALL';
+    const sorted = [...new Set(weekdays)].sort((a, b) => a - b);
+    const joined = sorted.join('-');
+    // Special cases
+    if (joined === '1-2-3-4-5')
+        return 'DU';
+    if (joined === '1-2-3-4-5-6-7')
+        return 'ALL';
+    const map = {
+        1: 'SEG',
+        2: 'TER',
+        3: 'QUA',
+        4: 'QUI',
+        5: 'SEX',
+        6: 'SAB',
+        7: 'DOM',
+    };
+    return sorted.map(day => map[day] || String(day)).join('-');
+}
+/**
+ * GTFS-oriented rule token:
+ * - FER_DU
+ * - VER_SAB
+ * - ESC_DOM
+ * - ALL
+ * - ALL_DU
+ * - VER-FER_SAB-DOM
+ * - event title for event rules (temporary)
+ */
+export function buildRuleSummaryGtfs(rule, options) {
+    if (isEventRestriction(rule) || isEventReplacement(rule)) {
+        return rule.event?.title ?? rule.name ?? rule._id;
+    }
+    if (rule.kind === 'manual' && rule.event_id) {
+        return getEventForManualRule(rule, options?.events)?.title ?? rule.name ?? rule._id;
+    }
+    const periodIds = rule.year_period_ids ?? [];
+    const weekdays = rule.weekdays ?? [];
+    const periodPart = mapPeriodsToGtfsAbbreviation(periodIds);
+    const weekdayPart = mapWeekdaysToGtfsAbbreviation(weekdays);
+    if (periodPart === 'ALL' && weekdayPart === 'ALL') {
+        return 'ALL';
+    }
+    if (periodPart === 'ALL') {
+        return `ALL_${weekdayPart}`;
+    }
+    if (weekdayPart === 'ALL') {
+        return periodPart;
+    }
+    return `${periodPart}_${weekdayPart}`;
+}

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

@@ -2,6 +2,7 @@ export * from './calculation/index.js';
 export * from './calculation/types.js';
 export * from './formatting/parameter-summary.js';
 export * from './formatting/rule-summary.js';
+export * from './merging/index.js';
 export * from './preview/affectedDates.js';
 export * from './preview/buildDayDetails.js';
 export * from './preview/computeRuleTimePoints.js';

package/dist/calendar/rules/index.js

@@ -2,6 +2,7 @@ export * from './calculation/index.js';
 export * from './calculation/types.js';
 export * from './formatting/parameter-summary.js';
 export * from './formatting/rule-summary.js';
+export * from './merging/index.js';
 export * from './preview/affectedDates.js';
 export * from './preview/buildDayDetails.js';
 export * from './preview/computeRuleTimePoints.js';

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

@@ -0,0 +1,5 @@
+import { Event, Pattern, ScheduleRule } from '@tmlmobilidade/types';
+/**
+ * Merges persisted pattern rules with event-derived rules relevant to this pattern.
+ */
+export declare function resolvePatternRules(pattern: Pattern, events: Event[]): ScheduleRule[];

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

@@ -0,0 +1,81 @@
+function eventRuleAffectsLine(rule, lineId) {
+    switch (rule.lines_mode) {
+        case 'all':
+            return true;
+        case 'exclude':
+            return !(rule.lines_to_exclude ?? []).includes(lineId);
+        case 'include':
+            return (rule.lines_to_include ?? []).includes(lineId);
+        default:
+            return false;
+    }
+}
+function buildEventDerivedRestriction(args) {
+    const { event, pattern, rule } = args;
+    if (!rule.dates?.length)
+        return null;
+    if (!eventRuleAffectsLine(rule, pattern.line_id))
+        return null;
+    return {
+        _id: `event:${event._id}:rule:${rule._id || 'unnamed'}`,
+        all_day: rule.all_day,
+        dates: rule.dates,
+        end_time: rule.end_time,
+        event: {
+            id: event._id,
+            title: event.title,
+        },
+        kind: 'event_restriction',
+        lines_mode: rule.lines_mode,
+        lines_to_exclude: rule.lines_to_exclude,
+        lines_to_include: rule.lines_to_include,
+        name: rule.name,
+        start_time: rule.start_time,
+    };
+}
+function buildEventDerivedReplacement(args) {
+    const { event, pattern, rule } = args;
+    if (!rule.dates?.length)
+        return null;
+    if (!eventRuleAffectsLine(rule, pattern.line_id))
+        return null;
+    if (!rule.weekdays?.length && !rule.year_period_ids?.length)
+        return null;
+    return {
+        _id: `event:${event._id}:rule:${rule._id || 'unnamed'}`,
+        dates: rule.dates,
+        event: {
+            id: event._id,
+            title: event.title,
+        },
+        kind: 'event_replacement',
+        lines_mode: rule.lines_mode,
+        lines_to_exclude: rule.lines_to_exclude,
+        lines_to_include: rule.lines_to_include,
+        name: rule.name,
+        same_weekday: rule.same_weekday,
+        weekdays: rule.weekdays,
+        year_period_ids: rule.year_period_ids,
+    };
+}
+/**
+ * Merges persisted pattern rules with event-derived rules relevant to this pattern.
+ */
+export function resolvePatternRules(pattern, events) {
+    const derivedRules = [];
+    for (const event of events) {
+        for (const rule of event.rules ?? []) {
+            if (rule.kind === 'event_restriction') {
+                const derived = buildEventDerivedRestriction({ event, pattern, rule });
+                if (derived)
+                    derivedRules.push(derived);
+            }
+            else if (rule.kind === 'event_replacement') {
+                const derived = buildEventDerivedReplacement({ event, pattern, rule });
+                if (derived)
+                    derivedRules.push(derived);
+            }
+        }
+    }
+    return [...(pattern.rules ?? []), ...derivedRules];
+}

package/dist/calendar/rules/preview/affectedDates.d.ts

@@ -1,4 +1,4 @@
-import { Event, ManualRule, YearPeriod } from '@tmlmobilidade/types';
+import { Event, Holiday, ManualRule, YearPeriod } from '@tmlmobilidade/types';
 /**
  * Context for computing which dates a manual rule affects within a calendar range.
  */
@@ -7,6 +7,8 @@ interface CalendarContext {
     endDate: Date;
     /** Optional events list for event_id matching */
     events?: Event[];
+    /** Available holidays for accurate weekday calculations */
+    holidays: Holiday[];
     /** Available periods for matching rule criteria */
     periods: YearPeriod[];
     /** Start date of the calendar range */

package/dist/calendar/rules/preview/affectedDates.js

@@ -16,7 +16,7 @@ function isInPeriod(rule, key, ctx) {
  * Checks both period membership and weekday matching.
  */
 function ruleAppliesToCivilKey(rule, key, ctx) {
-    const weekday = calendarWeekday(key);
+    const weekday = calendarWeekday(key, ctx.holidays);
     // 1) YearPeriod required
     if (!isInPeriod(rule, key, ctx))
         return false;
@@ -55,7 +55,7 @@ export function getManualRuleAffectedDates(rule, ctx) {
             if (key >= from && key <= to) {
                 // If weekdays are specified, narrow event dates to matching weekdays only
                 if (rule.weekdays?.length) {
-                    const weekday = calendarWeekday(key);
+                    const weekday = calendarWeekday(key, ctx.holidays);
                     if (!rule.weekdays.includes(weekday))
                         continue;
                 }

package/dist/calendar/rules/preview/buildDayDetails.d.ts

@@ -1,11 +1,11 @@
 import { CalendarKey } from '../../utils/index.js';
 import { Dates } from '../../../dates.js';
-import { type Event, type ScheduleRule, type YearPeriod } from '@tmlmobilidade/types';
+import { type Event, Holiday, type ScheduleRule, type YearPeriod } from '@tmlmobilidade/types';
 import { DayScheduleDetail } from './types.js';
 /**
  * Build schedule details for all affected days in a date range.
  * Only includes days that have active timepoints or applied rules.
  */
-export declare function buildAffectedDaysDetails(startDate: Dates, endDate: Dates, allRules: ScheduleRule[], periods: YearPeriod[], options?: {
+export declare function buildAffectedDaysDetails(startDate: Dates, endDate: Dates, allRules: ScheduleRule[], periods: YearPeriod[], holidays: Holiday[], options?: {
     events?: Event[];
 }): Map<CalendarKey, DayScheduleDetail>;

package/dist/calendar/rules/preview/buildDayDetails.js

@@ -1,9 +1,9 @@
 import { calendarKey, datesFromCalendarKey } from '../../utils/index.js';
 import { timeToMinutes } from '@tmlmobilidade/types';
 import { computeActiveRules } from '../calculation/index.js';
-function buildDayScheduleDetail(key, allRules, periods, events) {
+function buildDayScheduleDetail(key, allRules, periods, holidays, events) {
     const date = datesFromCalendarKey(key);
-    const { appliedRuleIds, timepoints: finalTimePoints } = computeActiveRules(date.operational_date, allRules, periods, { events });
+    const { appliedRuleIds, timepoints: finalTimePoints } = computeActiveRules(date.operational_date, allRules, periods, holidays, { events });
     const appliedRules = appliedRuleIds
         .map(id => allRules.find(r => r._id === id))
         .filter((r) => !!r);
@@ -86,12 +86,12 @@ function isTimeInRange(time, start, end) {
  * Build schedule details for all affected days in a date range.
  * Only includes days that have active timepoints or applied rules.
  */
-export function buildAffectedDaysDetails(startDate, endDate, allRules, periods, options) {
+export function buildAffectedDaysDetails(startDate, endDate, allRules, periods, holidays, options) {
     const affectedDays = new Map();
     let currentDate = startDate.startOf('day');
     while (currentDate.unix_timestamp <= endDate.unix_timestamp) {
         const key = calendarKey(currentDate);
-        const dayDetails = buildDayScheduleDetail(key, allRules, periods, options?.events);
+        const dayDetails = buildDayScheduleDetail(key, allRules, periods, holidays, options?.events);
         // Only include days that are "affected" (have active timepoints or applied rules)
         if (dayDetails.finalTimePoints.length > 0
             || dayDetails.includeRules.length > 0

package/dist/calendar/rules/preview/computeRuleTimePoints.d.ts

@@ -1,4 +1,4 @@
-import type { Event, ScheduleRule, YearPeriod } from '@tmlmobilidade/types';
+import type { Event, Holiday, ScheduleRule, YearPeriod } from '@tmlmobilidade/types';
 /**
  * Computes which timepoints are affected by a specific rule.
  * Returns the set of timepoints that should be displayed for this rule in the schedule grid.
@@ -8,6 +8,6 @@ import type { Event, ScheduleRule, YearPeriod } from '@tmlmobilidade/types';
  * - Event replacement rules: return timepoints that apply on the target weekdays
  * - Event restriction rules: return timepoints that are removed on the affected weekdays
  */
-export declare function computeRuleTimePoints(rule: ScheduleRule, allRules: ScheduleRule[], periods: YearPeriod[], options?: {
+export declare function computeRuleTimePoints(rule: ScheduleRule, allRules: ScheduleRule[], periods: YearPeriod[], holidays: Holiday[], options?: {
     events?: Event[];
 }): Set<string>;

package/dist/calendar/rules/preview/computeRuleTimePoints.js

@@ -12,7 +12,7 @@ import { buildOperationalDateRange } from '../utils/date.js';
  * - Event replacement rules: return timepoints that apply on the target weekdays
  * - Event restriction rules: return timepoints that are removed on the affected weekdays
  */
-export function computeRuleTimePoints(rule, allRules, periods, options) {
+export function computeRuleTimePoints(rule, allRules, periods, holidays, options) {
     // Manual rules: just return their timepoints
     if (rule.kind === 'manual') {
         if (!rule.event_id)
@@ -30,43 +30,36 @@ export function computeRuleTimePoints(rule, allRules, periods, options) {
     const affectedWeekdays = new Set();
     for (const opDate of relevantDates) {
         const key = calendarKey(Dates.fromOperationalDate(opDate, 'Europe/Lisbon'));
-        affectedWeekdays.add(calendarWeekday(key));
+        affectedWeekdays.add(calendarWeekday(key, holidays));
     }
     // For replacement rules: return timepoints from the TARGET weekdays
     if (rule.kind === 'event_replacement') {
-        // When same_weekday is true, each event date maps to its own actual weekday
-        const targetWeekdays = rule.same_weekday
-            ? affectedWeekdays
-            : new Set(rule.weekdays || []);
-        const targetPeriods = new Set(rule.year_period_ids || []);
-        // Find manual include rules that match the target pattern
-        const timepoints = new Set();
-        for (const r of allRules) {
-            if (r.kind !== 'manual' || r.operating_mode !== 'include')
-                continue;
-            // Check if this manual rule applies to the target weekdays/periods
-            const hasMatchingWeekday = r.weekdays?.some(w => targetWeekdays.has(w));
-            const hasMatchingPeriod = r.year_period_ids?.some(p => targetPeriods.has(p));
-            if (hasMatchingWeekday && hasMatchingPeriod) {
-                for (const tp of r.timepoints || []) {
-                    timepoints.add(tp);
+        const addedTimepoints = new Set();
+        for (const date of rule.dates ?? []) {
+            const withRule = computeActiveRules(date, allRules, periods, holidays, options);
+            const withoutRule = computeActiveRules(date, allRules.filter(r => r._id !== rule._id), periods, holidays, options);
+            const withSet = new Set(withRule.timepoints);
+            const withoutSet = new Set(withoutRule.timepoints);
+            for (const tp of withSet) {
+                if (!withoutSet.has(tp)) {
+                    addedTimepoints.add(tp);
                 }
             }
         }
-        return timepoints;
+        return addedTimepoints;
     }
     // For restriction rules: compute what was removed on affected weekdays
     // Generate a sample date range to check (1 year from now)
     const start = Dates.now('Europe/Lisbon').startOf('day').js_date;
     const end = Dates.fromJSDate(start).plus({ years: 1 }).js_date;
     const dateRange = buildOperationalDateRange(start, end);
-    const withAll = computeScheduleMap(allRules, dateRange, periods, options?.events);
-    const withoutRule = computeScheduleMap(allRules.filter(r => r._id !== rule._id), dateRange, periods, options?.events);
+    const withAll = computeScheduleMap(allRules, dateRange, periods, holidays, options?.events);
+    const withoutRule = computeScheduleMap(allRules.filter(r => r._id !== rule._id), dateRange, periods, holidays, options?.events);
     const removedTimePoints = new Set();
     // Check only dates that match the affected weekdays
     for (const opDate of dateRange) {
         const key = calendarKey(Dates.fromOperationalDate(opDate, 'Europe/Lisbon'));
-        const weekday = calendarWeekday(key);
+        const weekday = calendarWeekday(key, holidays);
         // Only look at days that match the affected weekdays
         if (!affectedWeekdays.has(weekday))
             continue;
@@ -84,11 +77,11 @@ export function computeRuleTimePoints(rule, allRules, periods, options) {
 /**
  * Helper: computes schedule for each date in range
  */
-function computeScheduleMap(rules, dateRange, periods, events) {
+function computeScheduleMap(rules, dateRange, periods, holidays, events) {
     const result = new Map();
     for (const date of dateRange) {
         const key = calendarKey(Dates.fromOperationalDate(date, 'Europe/Lisbon'));
-        const application = computeActiveRules(date, rules, periods, { events });
+        const application = computeActiveRules(date, rules, periods, holidays, { events });
         result.set(key, { timepoints: application.timepoints });
     }
     return result;

package/dist/calendar/utils/index.d.ts

@@ -1,6 +1,6 @@
 import { Dates } from '../../dates.js';
 import { TimezoneIdentified } from '../../types.js';
-import { IsoWeekday } from '@tmlmobilidade/types';
+import { Holiday, IsoWeekday } from '@tmlmobilidade/types';
 export declare const DEFAULT_CAL_TZ = "Europe/Lisbon";
 export type CalendarKey = `${number}-${number}-${number}`;
 export interface CalendarDay {
@@ -53,10 +53,11 @@ export declare function keyToYYYYMMDD(key: CalendarKey): string;
  * Convert "YYYYMMDD" to CalendarKey "YYYY-MM-DD".
  */
 export declare function yyyymmddToKey(yyyymmdd: string): CalendarKey;
+export declare function isHoliday(input: CalendarKey | Dates, holidays: Holiday[], tz?: TimezoneIdentified): boolean;
 /**
  * ISO weekday (1..7 Mon..Sun) for a calendar key or Dates (civil day).
  */
-export declare function calendarWeekday(input: CalendarKey | Dates, tz?: TimezoneIdentified): IsoWeekday;
+export declare function calendarWeekday(input: CalendarKey | Dates, holidays: Holiday[] | null, tz?: TimezoneIdentified): IsoWeekday;
 export declare function isWeekend(input: CalendarKey | Dates, tz?: TimezoneIdentified): boolean;
 /**
  * Iterate calendar day keys from start to end inclusive (civil days).

package/dist/calendar/utils/index.js

@@ -56,16 +56,24 @@ export function keyToYYYYMMDD(key) {
 export function yyyymmddToKey(yyyymmdd) {
     return `${yyyymmdd.slice(0, 4)}-${yyyymmdd.slice(4, 6)}-${yyyymmdd.slice(6, 8)}`;
 }
+export function isHoliday(input, holidays, tz = DEFAULT_CAL_TZ) {
+    const key = input instanceof Dates ? calendarKey(input, tz) : input;
+    const yyyymmdd = keyToYYYYMMDD(key);
+    return holidays.some(holiday => holiday.dates.includes(yyyymmdd));
+}
 /**
  * ISO weekday (1..7 Mon..Sun) for a calendar key or Dates (civil day).
  */
-export function calendarWeekday(input, tz = DEFAULT_CAL_TZ) {
+export function calendarWeekday(input, holidays, tz = DEFAULT_CAL_TZ) {
     const key = input instanceof Dates ? calendarKey(input, tz) : input;
+    if (holidays && isHoliday(key, holidays, tz)) {
+        return 7;
+    }
     const d = Dates.fromFormat(`${key} 12:00`, 'yyyy-MM-dd HH:mm', tz);
     return Number(d.toFormat('E'));
 }
 export function isWeekend(input, tz = DEFAULT_CAL_TZ) {
-    const wd = calendarWeekday(input, tz);
+    const wd = calendarWeekday(input, null, tz);
     return wd === 6 || wd === 7;
 }
 /**

package/package.json

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