@open-rlb/ng-bootstrap 3.3.17 → 3.3.18

package/fesm2022/open-rlb-ng-bootstrap.mjs

@@ -2513,17 +2513,43 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImpo
             args: [{ selector: 'rlb-fab', changeDetection: ChangeDetectionStrategy.OnPush, imports: [ButtonComponent], template: "<button rlb-button [color]=\"color()\" [disabled]=\"disabled()\" [outline]=\"outline()\"\n  class=\"fab-button d-flex align-items-center justify-content-center\" [class]=\"[sizeClass(), positionClass()]\">\n  <ng-content></ng-content>\n</button>", styles: [".fab-button{border-radius:50%;box-shadow:0 4px 12px #00000040;z-index:1050;transition:transform .2s ease,box-shadow .2s ease;padding:0}.fab-button:hover{transform:scale(1.08);box-shadow:0 6px 18px #00000059}.fab-button:active{transform:scale(.95)}:host{width:fit-content;display:block}.fab-xs{width:32px;height:32px;font-size:1rem}.fab-sm{width:44px;height:44px;font-size:1.2rem}.fab-md{width:56px;height:56px;font-size:1.4rem}.fab-lg{width:68px;height:68px;font-size:1.7rem}.fab-bottom-right{bottom:24px;right:24px}.fab-bottom-left{bottom:24px;left:24px}.fab-top-right{top:24px;right:24px}.fab-top-left{top:24px;left:24px}\n"] }]
         }], propDecorators: { color: [{ type: i0.Input, args: [{ isSignal: true, alias: "color", required: false }] }], size: [{ type: i0.Input, args: [{ isSignal: true, alias: "size", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], outline: [{ type: i0.Input, args: [{ isSignal: true, alias: "outline", required: false }] }], position: [{ type: i0.Input, args: [{ isSignal: true, alias: "position", required: false }] }] } });
 
+const MS_PER_DAY = 86_400_000;
+/**
+ * NOTE on date-tz: the getters (`.hour`, `.minute`, `.day`, `.dayOfWeek`, ...)
+ * and `toString()` are timezone-aware (they add `timezoneOffset` to the raw
+ * timestamp), but the mutators `set()`, `add()` and `stripSecMillis()` are
+ * timezone-NAIVE — they decompose/recompose the raw timestamp as if it were
+ * UTC. So `set(0, 'hour')` zeroes the UTC hour, not the local one.
+ *
+ * For calendar layout we need timezone-aware day math, so the helpers below
+ * derive day boundaries and intra-day offsets from the tz-aware side of the
+ * library instead of from `set()/add()`.
+ */
 /** Returns the IANA timezone resolved from the browser/runtime. */
 function getBrowserTimezone() {
     return Intl.DateTimeFormat().resolvedOptions().timeZone;
 }
+/** Epoch ms of local midnight (in `timezone`) of the day containing `d`. */
+function startOfDayTs(d, timezone) {
+    const local = d.cloneToTimezone(timezone);
+    const localMs = local.timestamp + local.timezoneOffset;
+    return Math.floor(localMs / MS_PER_DAY) * MS_PER_DAY - local.timezoneOffset;
+}
+/** Minutes elapsed since local midnight (in `timezone`) for `d`. */
+function minutesSinceMidnight(d, timezone) {
+    const local = d.cloneToTimezone(timezone);
+    return local.hour * 60 + local.minute;
+}
+/** Local-midnight instance (in `timezone`) for the day at index `offsetDays` from `d`. */
+function dayAt(d, timezone, offsetDays = 0) {
+    const baseMidnight = startOfDayTs(d, timezone);
+    // Re-floor after the raw day shift so DST transitions can't drift the result.
+    const shifted = new DateTz(baseMidnight + offsetDays * MS_PER_DAY, timezone);
+    return new DateTz(startOfDayTs(shifted, timezone), timezone);
+}
 function isSameDay(a, b, timezone) {
     const tz = timezone ?? getBrowserTimezone();
-    const da = a.cloneToTimezone(tz);
-    const db = b.cloneToTimezone(tz);
-    return da.year === db.year &&
-        da.month === db.month &&
-        da.day === db.day;
+    return startOfDayTs(a, tz) === startOfDayTs(b, tz);
 }
 function addDays(date, days) {
     return new DateTz(date.add(days, 'day'));
@@ -2532,17 +2558,9 @@ function startOfMonth(date) {
     const d = new DateTz(date);
     return d.set(1, 'day');
 }
-// export function endOfMonth(date: IDateTz): DateTz {
-// 	const d = new DateTz(date.timestamp, 'UTC');
-// 	return d.add(1, 'month').set(1, 'day').add(-1, 'day');
-// }
 function isToday(date, timezone) {
     const tz = timezone ?? getBrowserTimezone();
-    const d = date.cloneToTimezone(tz);
-    const today = getToday(tz);
-    return d.year === today.year &&
-        d.month === today.month &&
-        d.day === today.day;
+    return startOfDayTs(date, tz) === startOfDayTs(getToday(tz), tz);
 }
 function getToday(timezone) {
     return DateTz.now(timezone ?? getBrowserTimezone());
@@ -2733,13 +2751,12 @@ class CalendarWeekGridComponent {
         const rawMinutesFromStart = (newTopPx / this.layout().rowHeight) * 60;
         const snappedMinutes = Math.round(rawMinutesFromStart / this.SNAP_MINUTES) * this.SNAP_MINUTES;
         const validMinutes = Math.max(0, snappedMinutes);
-        const newStart = new DateTz$1(newDay)
-            .set(0, 'hour')
-            .set(0, 'minute')
-            .add(validMinutes, 'minute')
-            .stripSecMillis();
+        // Local midnight of the target day + dropped offset (tz-aware).
+        const tz = this.timezone();
+        const newStartTs = startOfDayTs(newDay, tz) + validMinutes * 60 * 1000;
+        const newStart = new DateTz$1(newStartTs, tz).stripSecMillis();
         const durationMs = movedEvent.end.timestamp - movedEvent.start.timestamp;
-        const newEnd = new DateTz$1(newStart.timestamp + durationMs, newStart.timezone).stripSecMillis();
+        const newEnd = new DateTz$1(newStart.timestamp + durationMs, tz).stripSecMillis();
         if (newStart.timestamp !== movedEvent.start.timestamp) {
             const updatedEvent = {
                 ...movedEvent,
@@ -2750,13 +2767,10 @@ class CalendarWeekGridComponent {
         }
     }
     getEventsForDay(day) {
-        const dayTs = new DateTz$1(day).set(0, 'hour').set(0, 'minute').stripSecMillis().timestamp;
-        return this.processedEvents().get(dayTs) || [];
+        return this.processedEvents().get(startOfDayTs(day, this.timezone())) || [];
     }
     calculateEventTop(event) {
-        const startOfDay = new DateTz$1(event.start).set(0, 'hour').set(0, 'minute').stripSecMillis();
-        const diffMs = event.start.timestamp - startOfDay.timestamp;
-        const diffMinutes = diffMs / (1000 * 60);
+        const diffMinutes = minutesSinceMidnight(event.start, this.timezone());
         return (diffMinutes / 60) * this.layout().rowHeight;
     }
     calculateEventHeight(event) {
@@ -2803,16 +2817,13 @@ class CalendarWeekGridComponent {
         return `var(--bs-${interval.color || 'success'})`;
     }
     buildWeekGrid(currentDate) {
-        const dayOfWeek = currentDate.dayOfWeek; // 0 = Sunday, 1 = Monday ...
-        // Week init (monday)
-        const start = new DateTz$1(currentDate)
-            .add(-(dayOfWeek - 1), 'day') // clone or create new for start date
-            .set(0, 'hour')
-            .set(0, 'minute')
-            .stripSecMillis();
+        const tz = this.timezone();
+        const dayOfWeek = currentDate.cloneToTimezone(tz).dayOfWeek; // 0 = Sunday, 1 = Monday ...
+        // Offset (in days) from currentDate back to the week's Monday.
+        const mondayOffset = 1 - dayOfWeek; // Sun(0) -> +1, Mon(1) -> 0, Tue(2) -> -1 ...
         const newDays = [];
         for (let i = 0; i < 7; i++) {
-            newDays.push(new DateTz$1(start).add(i, 'day'));
+            newDays.push(dayAt(currentDate, tz, mondayOffset + i));
         }
         this.days.set(newDays);
         this.startNowTimer();
@@ -2833,37 +2844,32 @@ class CalendarWeekGridComponent {
     }
     processAllEvents(events) {
         const eventsByDay = new Map();
+        const tz = this.timezone();
         for (const event of events) {
-            const originalStart = new DateTz$1(event.start).stripSecMillis();
-            const originalEnd = new DateTz$1(event.end).stripSecMillis();
-            let currentChunkStart = new DateTz$1(originalStart);
-            while (currentChunkStart.timestamp < originalEnd.timestamp) {
-                const startOfNextDay = new DateTz$1(currentChunkStart)
-                    .set(0, 'hour')
-                    .set(0, 'minute')
-                    .add(1, 'day')
-                    .stripSecMillis();
-                const chunkEndTimestamp = Math.min(originalEnd.timestamp, startOfNextDay.timestamp);
-                const chunkEnd = new DateTz$1(chunkEndTimestamp);
-                const currentDayStart = new DateTz$1(currentChunkStart)
-                    .set(0, 'hour')
-                    .set(0, 'minute')
-                    .stripSecMillis();
-                const dayTimestamp = currentDayStart.timestamp;
+            const originalStartTs = new DateTz$1(event.start).stripSecMillis().timestamp;
+            const originalEndTs = new DateTz$1(event.end).stripSecMillis().timestamp;
+            let chunkStartTs = originalStartTs;
+            while (chunkStartTs < originalEndTs) {
+                const chunkInst = new DateTz$1(chunkStartTs, tz);
+                // tz-aware day boundaries (set()/add() would be UTC-naive here).
+                const dayStartTs = startOfDayTs(chunkInst, tz);
+                const startOfNextDayTs = dayAt(chunkInst, tz, 1).timestamp;
+                const chunkEndTs = Math.min(originalEndTs, startOfNextDayTs);
                 const visualEvent = {
                     ...event,
-                    start: currentChunkStart,
-                    end: chunkEnd,
-                    isContinuedBefore: currentChunkStart.timestamp > originalStart.timestamp,
-                    isContinuedAfter: chunkEnd.timestamp < originalEnd.timestamp,
+                    // Chunks live in the calendar timezone, so labels and positions agree.
+                    start: new DateTz$1(chunkStartTs, tz),
+                    end: new DateTz$1(chunkEndTs, tz),
+                    isContinuedBefore: chunkStartTs > originalStartTs,
+                    isContinuedAfter: chunkEndTs < originalEndTs,
                     left: 0,
                     width: 0
                 };
-                if (!eventsByDay.has(dayTimestamp)) {
-                    eventsByDay.set(dayTimestamp, []);
+                if (!eventsByDay.has(dayStartTs)) {
+                    eventsByDay.set(dayStartTs, []);
                 }
-                eventsByDay.get(dayTimestamp).push(visualEvent);
-                currentChunkStart = startOfNextDay;
+                eventsByDay.get(dayStartTs).push(visualEvent);
+                chunkStartTs = startOfNextDayTs;
             }
         }
         const newProcessedEvents = new Map();
@@ -3079,21 +3085,18 @@ class CalendarMonthGridComponent {
     }
     // --- Core Logic ---
     buildMonthGrid() {
-        // 1. Calculate Grid Boundaries
-        const current = new DateTz(this.currentDate());
-        // Find the first day of the month
-        const startOfMonth = new DateTz(current).set(1, 'day').set(0, 'hour').set(0, 'minute').stripSecMillis();
-        // Calculate offset to find the start of the grid (e.g. Monday)
-        const dayOfWeek = startOfMonth.dayOfWeek; // 0 = Sun, 1 = Mon...
-        // Adjust logic based on your locale start of week (assuming Monday start here)
+        const tz = this.timezone();
+        // 1. Calculate Grid Boundaries (tz-aware; set()/add() would be UTC-naive)
+        const current = this.currentDate().cloneToTimezone(tz);
+        // First day of the month at local midnight
+        const firstOfMonth = dayAt(current, tz, -(current.day - 1));
+        // Calculate offset to find the start of the grid (Monday-first)
+        const dayOfWeek = firstOfMonth.dayOfWeek; // 0 = Sun, 1 = Mon...
         const offset = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
-        const gridStart = new DateTz(startOfMonth).add(-offset, 'day');
         // 2. Generate Days
         const days = [];
-        let iter = new DateTz(gridStart);
         for (let i = 0; i < DAYS_IN_GRID; i++) {
-            days.push(iter);
-            iter = new DateTz(iter).add(1, 'day');
+            days.push(dayAt(firstOfMonth, tz, i - offset));
         }
         // Header is just the first week
         this.weekDaysHeader.set(days.slice(0, 7));
@@ -3148,6 +3151,7 @@ class CalendarMonthGridComponent {
      * Places events into rows so that long events maintain their vertical position across days.
      */
     calculateEventSlots(days, events) {
+        const tz = this.timezone();
         const dayMap = new Map();
         days.forEach(d => dayMap.set(d.timestamp, []));
         // Sort: Longest events first, then by start time
@@ -3161,25 +3165,18 @@ class CalendarMonthGridComponent {
         const gridStartTs = days[0].timestamp;
         const lastDay = days[days.length - 1];
         // End of grid is the start of the next day after the last cell
-        const gridEndTs = new DateTz(lastDay).add(1, 'day').timestamp;
+        const gridEndTs = dayAt(lastDay, tz, 1).timestamp;
         for (const event of sortedEvents) {
-            // Normalize start to beginning of day
-            const evtStart = new DateTz(event.start).set(0, 'hour').set(0, 'minute').stripSecMillis();
-            const evtEndRaw = new DateTz(event.end).stripSecMillis();
-            // Normalize end.
-            // If ends at 00:00, it effectively ends at the previous day visually.
-            // Else, round up to the end of that day.
-            let evtEnd;
-            const isMidnight = evtEndRaw.hour === 0 && evtEndRaw.minute === 0;
-            if (evtEndRaw.timestamp > evtStart.timestamp && isMidnight) {
-                evtEnd = evtEndRaw; // Keeps it clean for comparison, effectively 00:00 of next day
-            }
-            else {
-                // Round to start of next day to cover full day
-                evtEnd = new DateTz(evtEndRaw).set(0, 'hour').set(0, 'minute').add(1, 'day').stripSecMillis();
-            }
+            // tz-aware day-floors (set()/add() would be UTC-naive).
+            const evtStartTs = startOfDayTs(event.start, tz);
+            // Normalize end. If it ends exactly at local 00:00, it visually ends on the
+            // previous day; otherwise round up to the start of the next day.
+            const endsAtMidnight = minutesSinceMidnight(event.end, tz) === 0;
+            const evtEndTs = (event.end.timestamp > evtStartTs && endsAtMidnight)
+                ? startOfDayTs(event.end, tz)
+                : dayAt(event.end, tz, 1).timestamp;
             // Skip if completely outside grid
-            if (evtEnd.timestamp <= gridStartTs || evtStart.timestamp >= gridEndTs) {
+            if (evtEndTs <= gridStartTs || evtStartTs >= gridEndTs) {
                 continue;
             }
             // Find which grid indices this event occupies
@@ -3187,7 +3184,7 @@ class CalendarMonthGridComponent {
             for (let i = 0; i < days.length; i++) {
                 const dTs = days[i].timestamp;
                 // Check intersection: [DayStart, DayEnd) overlaps [EventStart, EventEnd)
-                if (dTs >= evtStart.timestamp && dTs < evtEnd.timestamp) {
+                if (dTs >= evtStartTs && dTs < evtEndTs) {
                     daysIndices.push(i);
                 }
             }
@@ -3226,10 +3223,10 @@ class CalendarMonthGridComponent {
                 const isLastRenderDay = (i === daysIndices.length - 1);
                 // `dayInTz` is the grid cell, already in the calendar timezone.
                 const dayInTz = days[idx];
-                const currentDayEnd = new DateTz(dayInTz).add(1, 'day');
+                const currentDayEnd = dayAt(dayInTz, tz, 1);
                 // Visual flags for rounding corners
-                const isContinuedBefore = !isFirstRenderDay || (evtStart.timestamp < days[daysIndices[0]].timestamp);
-                const isContinuedAfter = !isLastRenderDay || (evtEnd.timestamp > currentDayEnd.timestamp);
+                const isContinuedBefore = !isFirstRenderDay || (evtStartTs < days[daysIndices[0]].timestamp);
+                const isContinuedAfter = !isLastRenderDay || (evtEndTs > currentDayEnd.timestamp);
                 const eventView = {
                     ...event,
                     // Override start/end for the specific cell (crucial for DnD to know the cell context)
@@ -3327,13 +3324,12 @@ class CalendarDayGridComponent {
         const rawMinutesFromStart = (newTopPx / this.layout().rowHeight) * 60;
         const snappedMinutes = Math.round(rawMinutesFromStart / this.SNAP_MINUTES) * this.SNAP_MINUTES;
         const validMinutes = Math.max(0, snappedMinutes);
-        const newStart = new DateTz$1(newDay)
-            .set(0, 'hour')
-            .set(0, 'minute')
-            .add(validMinutes, 'minute')
-            .stripSecMillis();
+        // Local midnight of the target day + dropped offset (tz-aware).
+        const tz = this.timezone();
+        const newStartTs = startOfDayTs(newDay, tz) + validMinutes * 60 * 1000;
+        const newStart = new DateTz$1(newStartTs, tz).stripSecMillis();
         const durationMs = movedEvent.end.timestamp - movedEvent.start.timestamp;
-        const newEnd = new DateTz$1(newStart.timestamp + durationMs, newStart.timezone).stripSecMillis();
+        const newEnd = new DateTz$1(newStart.timestamp + durationMs, tz).stripSecMillis();
         if (newStart.timestamp !== movedEvent.start.timestamp) {
             const updatedEvent = {
                 ...movedEvent,
@@ -3344,16 +3340,9 @@ class CalendarDayGridComponent {
         }
     }
     calculateEventTop(event) {
-        const startOfDay = new DateTz$1(this.day()).set(0, 'hour').set(0, 'minute').stripSecMillis();
-        // Use event.start directly, but ensure we are calculating relative to THIS day
-        // If event starts on previous day, we should clamp?
-        // Logic from week grid handles "chunks", here we assume processAllEvents has given us the chunk for this day.
-        let eventStart = new DateTz$1(event.start);
-        if (eventStart.timestamp < startOfDay.timestamp) {
-            eventStart = startOfDay;
-        }
-        const diffMs = eventStart.timestamp - startOfDay.timestamp;
-        const diffMinutes = diffMs / (1000 * 60);
+        // processAllEvents already clamped the event to this day, so its start is
+        // within [00:00, 24:00) of the day. Minutes-since-local-midnight is tz-aware.
+        const diffMinutes = minutesSinceMidnight(event.start, this.timezone());
         return (diffMinutes / 60) * this.layout().rowHeight;
     }
     calculateEventHeight(event) {
@@ -3400,7 +3389,8 @@ class CalendarDayGridComponent {
         return `var(--bs-${interval.color || 'success'})`;
     }
     buildDayGrid(currentDate) {
-        this.day.set(currentDate);
+        // Anchor the day to local midnight in the calendar timezone.
+        this.day.set(dayAt(currentDate, this.timezone(), 0));
         this.startNowTimer();
     }
     buildTimeSlots() {
@@ -3420,29 +3410,23 @@ class CalendarDayGridComponent {
     processAllEvents(events, day) {
         if (!day)
             return;
-        // Filter events for this day
-        const dayStart = new DateTz$1(day).set(0, 'hour').set(0, 'minute').stripSecMillis();
-        const dayEnd = new DateTz$1(day).set(0, 'hour').set(0, 'minute').add(1, 'day').stripSecMillis();
+        const tz = this.timezone();
+        // tz-aware day boundaries (set()/add() would be UTC-naive here).
+        const dayStartTs = startOfDayTs(day, tz);
+        const dayEndTs = dayAt(day, tz, 1).timestamp;
         const dayEvents = [];
         for (const event of events) {
             // Check overlap with the day
-            if (event.end.timestamp > dayStart.timestamp && event.start.timestamp < dayEnd.timestamp) {
-                let visualStart = event.start;
-                let visualEnd = event.end;
-                let isContinuedBefore = false;
-                let isContinuedAfter = false;
-                if (visualStart.timestamp < dayStart.timestamp) {
-                    visualStart = dayStart;
-                    isContinuedBefore = true;
-                }
-                if (visualEnd.timestamp > dayEnd.timestamp) {
-                    visualEnd = dayEnd;
-                    isContinuedAfter = true;
-                }
+            if (event.end.timestamp > dayStartTs && event.start.timestamp < dayEndTs) {
+                const isContinuedBefore = event.start.timestamp < dayStartTs;
+                const isContinuedAfter = event.end.timestamp > dayEndTs;
+                const visualStartTs = Math.max(event.start.timestamp, dayStartTs);
+                const visualEndTs = Math.min(event.end.timestamp, dayEndTs);
                 dayEvents.push({
                     ...event,
-                    start: visualStart,
-                    end: visualEnd,
+                    // Chunks live in the calendar timezone, so labels and positions agree.
+                    start: new DateTz$1(visualStartTs, tz),
+                    end: new DateTz$1(visualEndTs, tz),
                     isContinuedBefore,
                     isContinuedAfter,
                     left: 0,