@tmlmobilidade/dates 20260324.1728.13 → 20260324.1820.40

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

@@ -58,12 +58,17 @@ export function computeActiveRules(date, rules, periods, options) {
     let timepoints;
     let appliedRuleIds;
     if (replacement) {
+        // 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;
         // Replacement mode: match manuals by intersection (Option A)
-        const base = collectReplacementManualIncludes(replacement, filteredManualRules);
+        const base = collectReplacementManualIncludes(effectiveReplacement, filteredManualRules);
         timepoints = base.timepoints;
         appliedRuleIds = base.appliedRuleIds;
         // Apply manual excludes *also* by intersection with replacement targets
-        applyReplacementManualExcludes(timepoints, appliedRuleIds, replacement, filteredManualRules);
+        applyReplacementManualExcludes(timepoints, appliedRuleIds, effectiveReplacement, filteredManualRules);
     }
     else {
         // Normal mode: day resolves to a single weekday + single yearPeriodId

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

@@ -16,6 +16,16 @@
  * ```
  */
 export function manualRuleMatchesContext(rule, ctx) {
+    if (rule.event_id) {
+        // Event-exception rules: date matching already done by filteredManualRules in computeActiveRules.
+        // year_period_ids is cleared for these rules, so skip that check.
+        // If weekdays is non-empty, the user narrowed the event to specific days — check it.
+        // If weekdays is empty, all days of the event are included.
+        if (rule.weekdays.length > 0) {
+            return rule.weekdays.includes(ctx.weekday);
+        }
+        return true;
+    }
     // Strict by design: rule must include the weekday and the yearPeriodId.
     return rule.weekdays.includes(ctx.weekday) && rule.year_period_ids.includes(ctx.yearPeriodId);
 }

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

@@ -62,7 +62,11 @@ function buildRuleSummaryShort(rule, options) {
         return rule.event?.title ?? '';
     }
     if (rule.kind === 'manual' && rule.event_id) {
-        return getEventForManualRule(rule, options?.events)?.title ?? '';
+        const title = getEventForManualRule(rule, options?.events)?.title ?? '';
+        if (!rule.weekdays?.length)
+            return title;
+        const weekdayPart = buildWeekdaysPart(rule, { mode: 'short' });
+        return [title, weekdayPart].filter(Boolean).join(' · ');
     }
     // manual
     const parts = [];
@@ -85,7 +89,11 @@ function buildRuleSummaryLong(rule, options) {
         return rule.event?.title ?? '';
     }
     if (rule.kind === 'manual' && rule.event_id) {
-        return getEventForManualRule(rule, options?.events)?.title ?? '';
+        const title = getEventForManualRule(rule, options?.events)?.title ?? '';
+        if (!rule.weekdays?.length)
+            return title;
+        const weekdayPart = buildWeekdaysPart(rule, { mode: 'long' });
+        return [title, weekdayPart].filter(Boolean).join(', ');
     }
     // manual
     const parts = [];
@@ -108,6 +116,13 @@ function formatDateWithWeekday(date) {
     const weekdayShort = ['Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sáb'][weekday];
     return `${formattedDate} (${weekdayShort})`;
 }
+function truncateDates(dates, max = 5) {
+    if (dates.length <= max)
+        return dates.join(', ');
+    const visible = dates.slice(0, max);
+    const remaining = dates.length - max;
+    return `${visible.join(', ')} e mais ${remaining}`;
+}
 /**
  * Builds detailed tooltip text for event rules.
  *
@@ -117,7 +132,8 @@ function formatDateWithWeekday(date) {
  */
 function buildRuleSummaryTooltip(rule, options) {
     if (isEventRestriction(rule)) {
-        const dates = (rule.dates ?? []).map(formatDateWithWeekday).join(', ');
+        const formattedDates = (rule.dates ?? []).map(formatDateWithWeekday);
+        const dates = truncateDates(formattedDates);
         const datesText = (rule.dates?.length ?? 0) > 1 ? `nos dias ${dates}` : `no dia ${dates}`;
         const timeWindow = (rule?.start_time && rule?.end_time)
             ? `entre as ${rule.start_time}h e ${rule.end_time}h`
@@ -125,24 +141,36 @@ function buildRuleSummaryTooltip(rule, options) {
         return `Oferta excluída ${datesText}, ${timeWindow}`.trim();
     }
     if (isEventReplacement(rule)) {
-        const dates = (rule.dates ?? []).map(formatDateWithWeekday).join(', ');
+        const formattedDates = [...(rule.dates ?? [])].sort().map(formatDateWithWeekday);
+        const dates = truncateDates(formattedDates);
         const datesText = (rule.dates?.length ?? 0) > 1 ? `nos dias ${dates}` : `no dia ${dates}`;
+        const periods = rule.year_period_ids
+            ?.map(id => options?.periods?.find(p => p._id === id)?.name || id)
+            .join(', ') || '';
+        if (rule.same_weekday) {
+            const parts = ['mesmo dia da semana', periods].filter(Boolean);
+            return `Funcionará como ${parts.join(' · ')}, ${datesText}`;
+        }
         const weekdays = rule.weekdays
             ?.map(wd => WEEKDAY_OPTIONS.find(opt => opt.value === wd)?.label)
             .filter(Boolean)
             .join(', ') ?? '';
-        const periods = rule.year_period_ids
-            ?.map(id => options?.periods?.find(p => p._id === id)?.name || id)
-            .join(', ') || '';
         const parts = [weekdays, periods].filter(Boolean);
         return `Funcionará como ${parts.join(' · ')}, ${datesText}`;
     }
     if (rule.kind === 'manual' && rule.event_id) {
         const event = getEventForManualRule(rule, options?.events);
-        const dates = (event?.dates ?? []).map(formatDateWithWeekday).join(', ');
+        const filteredDates = (event?.dates ?? []).filter((date) => {
+            if (!rule.weekdays?.length)
+                return true;
+            const jsDay = Dates.fromOperationalDate(date, 'Europe/Lisbon').js_date.getDay();
+            const isoWeekday = (jsDay === 0 ? 7 : jsDay);
+            return rule.weekdays.includes(isoWeekday);
+        });
+        const dates = truncateDates(filteredDates.map(formatDateWithWeekday));
         if (!dates)
             return '';
-        const datesText = (event?.dates?.length ?? 0) > 1 ? `nos dias ${dates}` : `no dia ${dates}`;
+        const datesText = filteredDates.length > 1 ? `nos dias ${dates}` : `no dia ${dates}`;
         return `Aplicável ${datesText}`;
     }
     return '';

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

@@ -53,6 +53,12 @@ export function getManualRuleAffectedDates(rule, ctx) {
         for (const opDate of event.dates) {
             const key = calendarKey(Dates.fromOperationalDate(opDate, 'Europe/Lisbon'));
             if (key >= from && key <= to) {
+                // If weekdays are specified, narrow event dates to matching weekdays only
+                if (rule.weekdays?.length) {
+                    const weekday = calendarWeekday(key);
+                    if (!rule.weekdays.includes(weekday))
+                        continue;
+                }
                 affected.push(key);
             }
         }

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

@@ -34,7 +34,10 @@ export function computeRuleTimePoints(rule, allRules, periods, options) {
     }
     // For replacement rules: return timepoints from the TARGET weekdays
     if (rule.kind === 'event_replacement') {
-        const targetWeekdays = new Set(rule.weekdays || []);
+        // 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();

package/dist/calendar/utils/index.js

@@ -99,7 +99,7 @@ export function isKeyInRange(key, start, end) {
 export function generateMonthGrid(year, month, fixedWeeks = false, tz = DEFAULT_CAL_TZ) {
     // Create the first day of the target month at noon in tz to avoid DST edge cases
     const firstDayOfMonth = Dates.fromFormat(`${year}-${String(month).padStart(2, '0')}-01 12:00`, 'yyyy-MM-dd HH:mm', tz);
-    const lastDayOfMonth = firstDayOfMonth.endOf('month');
+    const lastDayOfMonth = firstDayOfMonth.endOf('month').set({ hour: 12, millisecond: 0, minute: 0, second: 0 });
     // Today (civil)
     const todayKey = calendarKey(Dates.now(tz), tz);
     // ISO weekday for first day (1=Mon..7=Sun)
@@ -136,9 +136,12 @@ export function generateMonthGrid(year, month, fixedWeeks = false, tz = DEFAULT_
         pushDay(firstDayOfMonth.plus({ days: d - 1 }), true);
     }
     // Next month overflow
+    // Use firstDayOfMonth (noon, tz-stable) as anchor instead of lastDayOfMonth (23:59 UTC),
+    // which crosses midnight into the next civil day when converted to a UTC+ timezone (e.g.
+    // Lisbon entering DST on March 29: 23:59 UTC = 00:59+01:00 = next day).
     const daysFromNextMonth = fixedWeeks ? 42 - days.length : naturalDaysFromNextMonth;
     for (let i = 1; i <= daysFromNextMonth; i++) {
-        pushDay(lastDayOfMonth.plus({ days: i }), false);
+        pushDay(firstDayOfMonth.plus({ days: daysInMonth + i - 1 }), false);
     }
     // Weeks (rows)
     const weeks = [];

package/package.json

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