@uxf/datepicker 11.111.2 → 11.113.0

package/utils/dst-robustness.test.js

@@ -0,0 +1,328 @@
+"use strict";
+/**
+ * DST robustness tests. Utility functions now operate on DateString, so they are
+ * inherently timezone-proof. These tests verify string-based comparison correctness
+ * across DST boundaries and large UTC offsets.
+ *
+ * Run with:
+ *   npm run test:tz:prague -w @uxf/datepicker
+ *   npm run test:tz:ny -w @uxf/datepicker
+ *   npm run test:tz:tokyo -w @uxf/datepicker
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const can_select_range_1 = require("./can-select-range");
+const date_string_1 = require("./date-string");
+const get_current_year_month_and_date_1 = require("./get-current-year-month-and-date");
+const get_days_1 = require("./get-days");
+const get_weekday_labels_1 = require("./get-weekday-labels");
+const get_years_1 = require("./get-years");
+const is_date_blocked_1 = require("./is-date-blocked");
+const is_date_hovered_1 = require("./is-date-hovered");
+const is_date_inside_range_1 = require("./is-date-inside-range");
+const is_end_date_1 = require("./is-end-date");
+const is_first_or_last_selected_date_1 = require("./is-first-or-last-selected-date");
+const is_in_unavailable_dates_1 = require("./is-in-unavailable-dates");
+const is_start_date_1 = require("./is-start-date");
+// Oct 25 2026 = DST fall-back in Europe/Prague (25h day, clocks go back)
+// Mar 29 2026 = DST spring-forward in Europe/Prague (23h day, clocks go forward)
+// Asia/Tokyo = UTC+9, no DST — local midnight is UTC previous-day 15:00 (extreme offset)
+describe("toDateString: local constructor vs ISO string are equivalent (any timezone)", () => {
+    test("DST fall-back day: new Date(2026, 9, 25) === new Date('2026-10-25')", () => {
+        // new Date(2026, 9, 25) = local midnight — different UTC timestamp than ISO string in UTC+ zones
+        expect((0, date_string_1.toDateString)(new Date(2026, 9, 25))).toBe("2026-10-25");
+        expect((0, date_string_1.toDateString)(new Date("2026-10-25"))).toBe("2026-10-25");
+        expect((0, date_string_1.toDateString)(new Date(2026, 9, 25))).toBe((0, date_string_1.toDateString)(new Date("2026-10-25")));
+    });
+    test("DST spring-forward day: new Date(2026, 2, 29) === new Date('2026-03-29')", () => {
+        expect((0, date_string_1.toDateString)(new Date(2026, 2, 29))).toBe("2026-03-29");
+        expect((0, date_string_1.toDateString)(new Date(2026, 2, 29))).toBe((0, date_string_1.toDateString)(new Date("2026-03-29")));
+    });
+    test("year-end: new Date(2025, 11, 31) === new Date('2025-12-31')", () => {
+        expect((0, date_string_1.toDateString)(new Date(2025, 11, 31))).toBe("2025-12-31");
+        expect((0, date_string_1.toDateString)(new Date(2025, 11, 31))).toBe((0, date_string_1.toDateString)(new Date("2025-12-31")));
+    });
+    test("year-start: new Date(2026, 0, 1) === new Date('2026-01-01')", () => {
+        expect((0, date_string_1.toDateString)(new Date(2026, 0, 1))).toBe("2026-01-01");
+        expect((0, date_string_1.toDateString)(new Date(2026, 0, 1))).toBe((0, date_string_1.toDateString)(new Date("2026-01-01")));
+    });
+});
+describe("DST fall-back Oct 25 2026 (Europe/Prague)", () => {
+    test("isStartDate: date on DST boundary matches", () => {
+        expect((0, is_start_date_1.isStartDate)("2026-10-25", "2026-10-25")).toBe(true);
+        expect((0, is_start_date_1.isStartDate)("2026-10-24", "2026-10-25")).toBe(false);
+        expect((0, is_start_date_1.isStartDate)("2026-10-26", "2026-10-25")).toBe(false);
+    });
+    test("isDateInsideRange: date on DST fall-back boundary is inside range", () => {
+        expect((0, is_date_inside_range_1.isDateInsideRange)("2026-10-25", "2026-10-24", "2026-10-26")).toBe(true);
+    });
+    test("isInUnavailableDates: date on DST boundary found in list", () => {
+        expect((0, is_in_unavailable_dates_1.isInUnavailableDates)(["2026-10-25"], "2026-10-25")).toBe(true);
+        expect((0, is_in_unavailable_dates_1.isInUnavailableDates)(["2026-10-24"], "2026-10-25")).toBe(false);
+    });
+    test("canSelectRange: 2-day range across DST fall-back is valid", () => {
+        expect((0, can_select_range_1.canSelectRange)({
+            startDate: "2026-10-25",
+            endDate: "2026-10-26",
+            minBookingDays: 2,
+            minBookingDate: undefined,
+            maxBookingDate: undefined,
+            exactMinBookingDays: false,
+            isDateBlocked: () => false,
+        })).toBe(true);
+    });
+    test("isDateBlocked: date on DST boundary not blocked when minBookingDate is same day", () => {
+        expect((0, is_date_blocked_1.isDateBlocked)({
+            date: "2026-10-25",
+            startDate: null,
+            endDate: null,
+            minBookingDate: "2026-10-25",
+        })).toBe(false);
+    });
+    test("isEndDate: date on DST boundary matches endDate", () => {
+        expect((0, is_end_date_1.isEndDate)("2026-10-25", "2026-10-25")).toBe(true);
+        expect((0, is_end_date_1.isEndDate)("2026-10-24", "2026-10-25")).toBe(false);
+    });
+    test("isFirstOrLastSelectedDate: DST boundary date matches start or end", () => {
+        expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2026-10-25", "2026-10-25", "2026-10-28")).toBe(true);
+        expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2026-10-28", "2026-10-25", "2026-10-28")).toBe(true);
+    });
+    test("isDateBlocked: date on DST boundary not blocked when maxBookingDate is same day", () => {
+        expect((0, is_date_blocked_1.isDateBlocked)({
+            date: "2026-10-25",
+            startDate: null,
+            endDate: null,
+            minBookingDate: undefined,
+            maxBookingDate: "2026-10-25",
+        })).toBe(false);
+    });
+});
+describe("DST spring-forward Mar 29 2026 (Europe/Prague)", () => {
+    test("canSelectRange: 2-day range across DST spring-forward is valid", () => {
+        expect((0, can_select_range_1.canSelectRange)({
+            startDate: "2026-03-29",
+            endDate: "2026-03-30",
+            minBookingDays: 2,
+            minBookingDate: undefined,
+            maxBookingDate: undefined,
+            exactMinBookingDays: false,
+            isDateBlocked: () => false,
+        })).toBe(true);
+    });
+    test("isDateInsideRange: date on spring-forward boundary is inside range", () => {
+        expect((0, is_date_inside_range_1.isDateInsideRange)("2026-03-29", "2026-03-28", "2026-03-30")).toBe(true);
+    });
+});
+describe("UTC+9 (Asia/Tokyo, no DST) — year-end boundary Dec 31 2025 / Jan 1 2026", () => {
+    test("isStartDate: year-end date matches", () => {
+        expect((0, is_start_date_1.isStartDate)("2025-12-31", "2025-12-31")).toBe(true);
+        expect((0, is_start_date_1.isStartDate)("2026-01-01", "2025-12-31")).toBe(false);
+    });
+    test("isEndDate: New Year's Day matches", () => {
+        expect((0, is_end_date_1.isEndDate)("2026-01-01", "2026-01-01")).toBe(true);
+        expect((0, is_end_date_1.isEndDate)("2025-12-31", "2026-01-01")).toBe(false);
+    });
+    test("isDateInsideRange: date on year-end boundary is inside range", () => {
+        expect((0, is_date_inside_range_1.isDateInsideRange)("2025-12-31", "2025-12-30", "2026-01-01")).toBe(true);
+        expect((0, is_date_inside_range_1.isDateInsideRange)("2026-01-01", "2025-12-31", "2026-01-02")).toBe(true);
+    });
+    test("isInUnavailableDates: year-end date found in list", () => {
+        expect((0, is_in_unavailable_dates_1.isInUnavailableDates)(["2025-12-31"], "2025-12-31")).toBe(true);
+        expect((0, is_in_unavailable_dates_1.isInUnavailableDates)(["2025-12-31"], "2026-01-01")).toBe(false);
+    });
+    test("canSelectRange: 2-day range spanning year boundary is valid", () => {
+        expect((0, can_select_range_1.canSelectRange)({
+            startDate: "2025-12-31",
+            endDate: "2026-01-01",
+            minBookingDays: 2,
+            minBookingDate: undefined,
+            maxBookingDate: undefined,
+            exactMinBookingDays: false,
+            isDateBlocked: () => false,
+        })).toBe(true);
+    });
+    test("canSelectRange: startDate on minBookingDate at year boundary is valid", () => {
+        expect((0, can_select_range_1.canSelectRange)({
+            startDate: "2026-01-01",
+            endDate: null,
+            minBookingDays: 1,
+            minBookingDate: "2025-12-31",
+            maxBookingDate: undefined,
+            exactMinBookingDays: false,
+            isDateBlocked: () => false,
+        })).toBe(true);
+    });
+    test("canSelectRange: endDate within maxBookingDate at year boundary is valid", () => {
+        expect((0, can_select_range_1.canSelectRange)({
+            startDate: "2025-12-30",
+            endDate: "2025-12-31",
+            minBookingDays: 2,
+            minBookingDate: undefined,
+            maxBookingDate: "2026-01-02",
+            exactMinBookingDays: false,
+            isDateBlocked: () => false,
+        })).toBe(true);
+    });
+    test("isDateBlocked: Dec 31 not blocked when minBookingDate is Dec 31", () => {
+        expect((0, is_date_blocked_1.isDateBlocked)({
+            date: "2025-12-31",
+            startDate: null,
+            endDate: null,
+            minBookingDate: "2025-12-31",
+        })).toBe(false);
+    });
+    test("isDateBlocked: Jan 1 not blocked when maxBookingDate is Jan 1", () => {
+        expect((0, is_date_blocked_1.isDateBlocked)({
+            date: "2026-01-01",
+            startDate: null,
+            endDate: null,
+            maxBookingDate: "2026-01-01",
+        })).toBe(false);
+    });
+    test("isDateBlocked: Dec 30 blocked when minBookingDate is Dec 31", () => {
+        expect((0, is_date_blocked_1.isDateBlocked)({
+            date: "2025-12-30",
+            startDate: null,
+            endDate: null,
+            minBookingDate: "2025-12-31",
+        })).toBe(true);
+    });
+    test("isDateBlocked: Jan 2 blocked when maxBookingDate is Jan 1", () => {
+        expect((0, is_date_blocked_1.isDateBlocked)({
+            date: "2026-01-02",
+            startDate: null,
+            endDate: null,
+            maxBookingDate: "2026-01-01",
+        })).toBe(true);
+    });
+    test("isFirstOrLastSelectedDate: year-end and new year match start/end", () => {
+        expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2025-12-31", "2025-12-31", "2026-01-03")).toBe(true);
+        expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2026-01-03", "2025-12-31", "2026-01-03")).toBe(true);
+        expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2026-01-01", "2025-12-31", "2026-01-03")).toBe(false);
+    });
+    test("isDateHovered: date between startDate and hoveredDate highlighted across year boundary", () => {
+        expect((0, is_date_hovered_1.isDateHovered)({
+            date: "2025-12-31",
+            startDate: "2025-12-29",
+            endDate: null,
+            isDateBlocked: () => false,
+            hoveredDate: "2026-01-03",
+            minBookingDays: 1,
+            exactMinBookingDays: false,
+        })).toBe(true);
+    });
+});
+describe("getDays: month boundaries correct in UTC+ timezone", () => {
+    // April 2026 with firstDayOfWeek=1 (Monday):
+    //   April 1 = Wednesday → 2 prev-month days (Mar 30, 31)
+    //   April 30 = Thursday → 3 next-month overflow days (May 1, 2, 3)
+    //   Total = 2 + 30 + 3 = 35 days
+    //
+    // Bug: in UTC+2 (Prague), dayjsEnWithTz().endOf("month").toDate() for April is
+    // 2026-04-30T23:59:59.999Z which local-methods read as 2026-05-01 →
+    // monthEndStr becomes "2026-05-01", so May 1 ends up in the current-month slice.
+    test("April 2026 calendar has exactly 35 days (5 weeks, firstDayOfWeek=1)", () => {
+        const days = (0, get_days_1.getDays)({ year: 2026, month: 3, firstDayOfWeek: 1 });
+        expect(days).toHaveLength(35);
+    });
+    test("last current-month day in April 2026 is April 30", () => {
+        const days = (0, get_days_1.getDays)({ year: 2026, month: 3, firstDayOfWeek: 1 });
+        const currentMonthDays = days.filter((d) => d.currentMonth);
+        expect(currentMonthDays).toHaveLength(30);
+        const last = currentMonthDays[currentMonthDays.length - 1];
+        expect((0, date_string_1.toDateString)(last.date)).toBe("2026-04-30");
+    });
+    test("May 1 appears as overflow (currentMonth: false) in April 2026 calendar", () => {
+        const days = (0, get_days_1.getDays)({ year: 2026, month: 3, firstDayOfWeek: 1 });
+        const may1 = days.find((d) => (0, date_string_1.toDateString)(d.date) === "2026-05-01");
+        expect(may1).toBeDefined();
+        expect(may1 === null || may1 === void 0 ? void 0 : may1.currentMonth).toBe(false);
+    });
+    test("overflow days after April 2026 are May 1, 2, 3", () => {
+        const days = (0, get_days_1.getDays)({ year: 2026, month: 3, firstDayOfWeek: 1 });
+        const overflow = days.filter((d) => !d.currentMonth && (0, date_string_1.toDateString)(d.date) >= "2026-05-01");
+        expect(overflow.map((d) => (0, date_string_1.toDateString)(d.date))).toEqual(["2026-05-01", "2026-05-02", "2026-05-03"]);
+    });
+});
+describe("getWeekdayLabels: exactly 7 labels in UTC+ timezone", () => {
+    // Bug: endOf("week").add(n, "day").toDate() has non-zero UTC ms (23:59:59.999Z).
+    // toDateString() falls back to local methods and shifts the date +1 day in UTC+
+    // timezones, so getEach() returns 8 dates → 8 labels (last one is a duplicate Mon).
+    test("returns exactly 7 labels with firstDayOfWeek=0", () => {
+        expect((0, get_weekday_labels_1.getWeekdayLabels)({ firstDayOfWeek: 0 })).toHaveLength(7);
+    });
+    test("returns exactly 7 labels with firstDayOfWeek=1 (Monday-start)", () => {
+        expect((0, get_weekday_labels_1.getWeekdayLabels)({ firstDayOfWeek: 1 })).toHaveLength(7);
+    });
+    test("Mo-start week is Mo…Su with no duplicates", () => {
+        expect((0, get_weekday_labels_1.getWeekdayLabels)({ firstDayOfWeek: 1 })).toEqual(["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"]);
+    });
+});
+describe("getYears: exactly 9 years for ±4 decade view in UTC+ timezone", () => {
+    // Bug: useDecade passed endOf("year").toDate() to getYears, which called toDateString()
+    // on 2030-12-31T23:59:59.999Z — local methods in CEST give 2031-01-01, adding a 10th year.
+    // Fix: useDecade now passes new Date(createDateString(year+4, 0)) (UTC midnight Jan 1).
+    test("year=2026: 9 years returned (2022–2030)", () => {
+        const startYear = new Date("2022-01-01");
+        const endYear = new Date("2030-01-01");
+        expect((0, get_years_1.getYears)({ startYear, endYear })).toHaveLength(9);
+    });
+    test("year=2026: first year is 2022, last is 2030", () => {
+        const startYear = new Date("2022-01-01");
+        const endYear = new Date("2030-01-01");
+        const years = (0, get_years_1.getYears)({ startYear, endYear });
+        expect(years[0].yearLabel).toBe("2022");
+        expect(years[years.length - 1].yearLabel).toBe("2030");
+    });
+});
+describe("getCurrentYearMonthAndDate: returns local calendar month in UTC+ timezone", () => {
+    // Bug: dayjsEnWithTz().startOf("day") anchors to UTC day, so at 00:30 local Prague
+    // time (= 22:30 UTC the previous day) it returns the previous UTC day's month.
+    // Fix: getDateMonthAndYear(new Date()) — toDateString(new Date()) uses local methods
+    // for any non-UTC-midnight time, giving the correct local calendar day.
+    beforeAll(() => jest.useFakeTimers());
+    afterAll(() => jest.useRealTimers());
+    test("returns local calendar month, not UTC month", () => {
+        // Set clock to 22:30 UTC = 00:30 local in UTC+2 (Prague CEST)
+        // In UTC the local month is still August (7); in Prague it is September (8).
+        // The function must always agree with the local calendar, whatever the offset.
+        jest.setSystemTime(new Date("2021-08-31T22:30:00Z"));
+        const expectedMonth = new Date("2021-08-31T22:30:00Z").getMonth(); // local month
+        const result = (0, get_current_year_month_and_date_1.getCurrentYearMonthAndDate)();
+        expect(result.month).toBe(expectedMonth);
+    });
+});
+describe("Range boundary checks", () => {
+    test("canSelectRange: startDate on minBookingDate boundary is valid", () => {
+        expect((0, can_select_range_1.canSelectRange)({
+            startDate: "2026-10-26",
+            endDate: null,
+            minBookingDays: 1,
+            minBookingDate: "2026-10-25",
+            maxBookingDate: undefined,
+            exactMinBookingDays: false,
+            isDateBlocked: () => false,
+        })).toBe(true);
+    });
+    test("canSelectRange: endDate within maxBookingDate boundary is valid", () => {
+        expect((0, can_select_range_1.canSelectRange)({
+            startDate: "2026-10-24",
+            endDate: "2026-10-25",
+            minBookingDays: 2,
+            minBookingDate: undefined,
+            maxBookingDate: "2026-10-26",
+            exactMinBookingDays: false,
+            isDateBlocked: () => false,
+        })).toBe(true);
+    });
+    test("isDateHovered: date between startDate and hoveredDate is highlighted", () => {
+        expect((0, is_date_hovered_1.isDateHovered)({
+            date: "2026-10-26",
+            startDate: "2026-10-24",
+            endDate: null,
+            isDateBlocked: () => false,
+            hoveredDate: "2026-10-28",
+            minBookingDays: 1,
+            exactMinBookingDays: false,
+        })).toBe(true);
+    });
+});

package/utils/get-current-year-month-and-date.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCurrentYearMonthAndDate = getCurrentYearMonthAndDate;
-const dayjs_utils_1 = require("./dayjs-utils");
 const get_date_month_and_year_1 = require("./get-date-month-and-year");
 function getCurrentYearMonthAndDate() {
-    return (0, get_date_month_and_year_1.getDateMonthAndYear)((0, dayjs_utils_1.dayjsEnWithTz)().startOf("day").toDate());
+    return (0, get_date_month_and_year_1.getDateMonthAndYear)(new Date());
 }

package/utils/get-date-invervals.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDateIntervals = getDateIntervals;
 const is_not_nil_1 = require("@uxf/core/utils/is-not-nil");
-const dayjs_utils_1 = require("./dayjs-utils");
+const date_string_1 = require("./date-string");
 function getDateIntervals(dates) {
     const sortedDates = dates.slice().sort((a, b) => a.getTime() - b.getTime());
     const intervals = [];
@@ -11,9 +11,7 @@ function getDateIntervals(dates) {
     let currentEnd = firstSortedDate !== null && firstSortedDate !== void 0 ? firstSortedDate : new Date();
     for (let i = 1; i < sortedDates.length; i++) {
         const currentDate = sortedDates[i];
-        const nextDate = (0, dayjs_utils_1.dayjsEnRaw)(currentEnd).add(1, "day").toDate();
-        // If the current date matches the expected next date, it's contiguous
-        if ((0, dayjs_utils_1.dayjsEnRaw)(currentDate).isSame(nextDate, "day")) {
+        if ((0, date_string_1.toDateString)(currentDate) === (0, date_string_1.addDays)((0, date_string_1.toDateString)(currentEnd), 1)) {
             currentEnd = currentDate;
         }
         else {
@@ -23,7 +21,6 @@ function getDateIntervals(dates) {
         }
     }
     if ((0, is_not_nil_1.isNotNil)(firstSortedDate)) {
-        // Push the last interval
         intervals.push({ start: currentStart, end: currentEnd });
     }
     return intervals;

package/utils/get-date-month-and-year.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDateMonthAndYear = getDateMonthAndYear;
-const dayjs_utils_1 = require("./dayjs-utils");
+const create_date_string_1 = require("./create-date-string");
+const date_string_1 = require("./date-string");
 function getDateMonthAndYear(date) {
-    const day = (0, dayjs_utils_1.dayjsEnWithTz)(date).startOf("month").toDate();
-    const year = (0, dayjs_utils_1.dayjsEnWithTz)(day).year();
-    const month = (0, dayjs_utils_1.dayjsEnWithTz)(day).month();
+    const ds = (0, date_string_1.toDateString)(date);
+    const year = parseInt(ds.slice(0, 4), 10);
+    const month = parseInt(ds.slice(5, 7), 10) - 1; // 0-indexed, matching dayjs convention
     return {
         year,
         month,
-        date: day,
+        date: (0, date_string_1.fromDateString)((0, create_date_string_1.createDateString)(year, month)),
     };
 }

package/utils/get-days.js

@@ -2,35 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDays = getDays;
 const create_date_string_1 = require("./create-date-string");
+const date_string_1 = require("./date-string");
 const dayjs_utils_1 = require("./dayjs-utils");
 const get_each_1 = require("./get-each");
 function getDays({ year, month, firstDayOfWeek = 0, dayLabelFormat = (date) => (0, dayjs_utils_1.dayjsEnWithTz)(date).format("DD"), }) {
     const date = new Date((0, create_date_string_1.createDateString)(year, month));
     const lastDayOfWeek = firstDayOfWeek + 7;
     const monthStart = (0, dayjs_utils_1.dayjsEnWithTz)(date).startOf("month");
+    const monthStartStr = monthStart.format("YYYY-MM-DD");
     const monthStartDay = monthStart.day();
     const monthEnd = (0, dayjs_utils_1.dayjsEnWithTz)(date).endOf("month");
+    const monthEndStr = monthEnd.format("YYYY-MM-DD");
     const monthEndDay = monthEnd.day();
     const prevMonthDaysCount = monthStartDay >= firstDayOfWeek ? monthStartDay - firstDayOfWeek : 6 - firstDayOfWeek + monthStartDay + 1;
     const prevMonthDays = prevMonthDaysCount > 0
-        ? (0, get_each_1.getEach)(monthStart.subtract(prevMonthDaysCount, "days").toDate(), monthStart.subtract(1, "day").toDate(), "day").map((d) => ({
+        ? (0, get_each_1.getEach)((0, date_string_1.addDays)(monthStartStr, -prevMonthDaysCount), (0, date_string_1.addDays)(monthStartStr, -1), "day").map((d) => ({
             currentMonth: false,
-            date: d,
-            dayLabel: dayLabelFormat(d),
+            date: (0, date_string_1.fromDateString)(d),
+            dayLabel: dayLabelFormat((0, date_string_1.fromDateString)(d)),
         }))
         : [];
     const nextMonthDaysCount = lastDayOfWeek - monthEndDay - 1;
     const nextMonthDays = nextMonthDaysCount > 0 && nextMonthDaysCount < 7
-        ? (0, get_each_1.getEach)(monthEnd.add(1, "day").toDate(), monthEnd.add(nextMonthDaysCount, "days").toDate(), "day").map((d) => ({
+        ? (0, get_each_1.getEach)((0, date_string_1.addDays)(monthEndStr, 1), (0, date_string_1.addDays)(monthEndStr, nextMonthDaysCount), "day").map((d) => ({
             currentMonth: false,
-            date: d,
-            dayLabel: dayLabelFormat(d),
+            date: (0, date_string_1.fromDateString)(d),
+            dayLabel: dayLabelFormat((0, date_string_1.fromDateString)(d)),
         }))
         : [];
-    const days = (0, get_each_1.getEach)(monthStart.toDate(), monthEnd.toDate(), "day").map((d) => ({
+    const days = (0, get_each_1.getEach)(monthStartStr, monthEndStr, "day").map((d) => ({
         currentMonth: true,
-        date: d,
-        dayLabel: dayLabelFormat(d),
+        date: (0, date_string_1.fromDateString)(d),
+        dayLabel: dayLabelFormat((0, date_string_1.fromDateString)(d)),
     }));
     return [...prevMonthDays, ...days, ...nextMonthDays];
 }

package/utils/get-each.d.ts

@@ -1 +1,2 @@
-export declare function getEach(start: Date, end: Date, type: "day" | "month" | "year"): Date[];
+import { DateString } from "@uxf/core/date";
+export declare function getEach(start: DateString, end: DateString, type: "day" | "month" | "year"): DateString[];

package/utils/get-each.js

@@ -1,18 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEach = getEach;
-const dayjs_utils_1 = require("./dayjs-utils");
+const create_date_string_1 = require("./create-date-string");
+const date_string_1 = require("./date-string");
+const DAY_MS = 86400000;
 function getEach(start, end, type) {
-    const startOfStart = (0, dayjs_utils_1.dayjsEnWithTz)(start).startOf(type);
-    const startOfEnd = (0, dayjs_utils_1.dayjsEnWithTz)(end).startOf(type);
-    if (startOfStart.toDate().getTime() > startOfEnd.toDate().getTime()) {
+    if (type === "day") {
+        const startMs = new Date(start).getTime();
+        const endMs = new Date(end).getTime();
+        if (startMs > endMs) {
+            throw new Error("start must precede end");
+        }
+        const count = Math.round((endMs - startMs) / DAY_MS) + 1;
+        const results = new Array(count);
+        for (let i = 0; i < count; i++) {
+            results[i] = (0, date_string_1.toDateString)(new Date(startMs + i * DAY_MS));
+        }
+        return results;
+    }
+    if (type === "month") {
+        const [sy, sm] = start.split("-").map(Number);
+        const [ey, em] = end.split("-").map(Number);
+        if (sy > ey || (sy === ey && sm > em)) {
+            throw new Error("start must precede end");
+        }
+        const count = (ey - sy) * 12 + (em - sm) + 1;
+        const results = new Array(count);
+        for (let i = 0; i < count; i++) {
+            const totalMonths = sm - 1 + i; // 0-indexed from start month
+            results[i] = (0, create_date_string_1.createDateString)(sy + Math.floor(totalMonths / 12), totalMonths % 12);
+        }
+        return results;
+    }
+    // type === "year"
+    const sy = parseInt(start.slice(0, 4), 10);
+    const ey = parseInt(end.slice(0, 4), 10);
+    if (sy > ey) {
         throw new Error("start must precede end");
     }
-    const results = [];
-    let current = startOfStart;
-    while (current.toDate().getTime() <= startOfEnd.toDate().getTime()) {
-        results.push(current.toDate());
-        current = current.add(1, type);
+    const results = new Array(ey - sy + 1);
+    for (let i = 0; i < results.length; i++) {
+        results[i] = (0, create_date_string_1.createDateString)(sy + i);
     }
     return results;
 }

package/utils/get-each.test.js

@@ -2,30 +2,45 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_each_1 = require("./get-each");
 test("getEach day", () => {
-    expect((0, get_each_1.getEach)(new Date("2021-05-05"), new Date("2021-05-07"), "day")).toStrictEqual([
-        new Date("2021-05-05T00:00:00Z"),
-        new Date("2021-05-06T00:00:00Z"),
-        new Date("2021-05-07T00:00:00Z"),
-    ]);
+    expect((0, get_each_1.getEach)("2021-05-05", "2021-05-07", "day")).toStrictEqual(["2021-05-05", "2021-05-06", "2021-05-07"]);
+});
+test("getEach day — DST fall-back (Oct 25 2026)", () => {
+    expect((0, get_each_1.getEach)("2026-10-24", "2026-10-26", "day")).toStrictEqual(["2026-10-24", "2026-10-25", "2026-10-26"]);
+});
+test("getEach day — DST spring-forward (Mar 29 2026)", () => {
+    expect((0, get_each_1.getEach)("2026-03-28", "2026-03-30", "day")).toStrictEqual(["2026-03-28", "2026-03-29", "2026-03-30"]);
 });
 test("getEach month", () => {
-    expect((0, get_each_1.getEach)(new Date("2021-05-05"), new Date("2021-08-07"), "month")).toStrictEqual([
-        new Date("2021-05-01T00:00:00Z"),
-        new Date("2021-06-01T00:00:00Z"),
-        new Date("2021-07-01T00:00:00Z"),
-        new Date("2021-08-01T00:00:00Z"),
+    expect((0, get_each_1.getEach)("2021-05-05", "2021-08-07", "month")).toStrictEqual([
+        "2021-05-01",
+        "2021-06-01",
+        "2021-07-01",
+        "2021-08-01",
+    ]);
+});
+test("getEach month — year boundary", () => {
+    expect((0, get_each_1.getEach)("2021-11-01", "2022-02-01", "month")).toStrictEqual([
+        "2021-11-01",
+        "2021-12-01",
+        "2022-01-01",
+        "2022-02-01",
     ]);
 });
 test("getEach year", () => {
-    expect((0, get_each_1.getEach)(new Date("2015-05-05"), new Date("2020-05-07"), "year")).toStrictEqual([
-        new Date("2015-01-01T00:00:00Z"),
-        new Date("2016-01-01T00:00:00Z"),
-        new Date("2017-01-01T00:00:00Z"),
-        new Date("2018-01-01T00:00:00Z"),
-        new Date("2019-01-01T00:00:00Z"),
-        new Date("2020-01-01T00:00:00Z"),
+    expect((0, get_each_1.getEach)("2015-05-05", "2020-05-07", "year")).toStrictEqual([
+        "2015-01-01",
+        "2016-01-01",
+        "2017-01-01",
+        "2018-01-01",
+        "2019-01-01",
+        "2020-01-01",
     ]);
 });
-test("getEach invalid input", () => {
-    expect(() => (0, get_each_1.getEach)(new Date("2015-05-05"), new Date("2014-05-07T00:00:00Z"), "day")).toThrow();
+test("getEach single day", () => {
+    expect((0, get_each_1.getEach)("2021-05-05", "2021-05-05", "day")).toStrictEqual(["2021-05-05"]);
+});
+test("getEach invalid input throws", () => {
+    expect(() => (0, get_each_1.getEach)("2015-05-05", "2014-05-07", "day")).toThrow("start must precede end");
+    expect(() => (0, get_each_1.getEach)("2021-06-01", "2021-05-01", "month")).toThrow("start must precede end");
+    expect(() => (0, get_each_1.getEach)("2020-01-01", "2019-01-01", "year")).toThrow("start must precede end");
 });

package/utils/get-initial-months.js

@@ -1,19 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getInitialMonths = getInitialMonths;
-const dayjs_utils_1 = require("./dayjs-utils");
+const date_string_1 = require("./date-string");
 const get_current_year_month_and_date_1 = require("./get-current-year-month-and-date");
 const get_date_month_and_year_1 = require("./get-date-month-and-year");
 function getInitialMonths(numberOfMonths, startDate) {
     const firstMonth = startDate ? (0, get_date_month_and_year_1.getDateMonthAndYear)(startDate) : (0, get_current_year_month_and_date_1.getCurrentYearMonthAndDate)();
-    let prevMonthDate = firstMonth.date;
     let months = [firstMonth];
     if (numberOfMonths > 1) {
         months = Array.from(Array(numberOfMonths - 1).keys()).reduce((m) => {
-            prevMonthDate = (0, dayjs_utils_1.dayjsEnWithTz)(m[m.length - 1].date)
-                .add(1, "month")
-                .toDate();
-            return m.concat([(0, get_date_month_and_year_1.getDateMonthAndYear)(prevMonthDate)]);
+            const nextDate = (0, date_string_1.fromDateString)((0, date_string_1.addMonths)((0, date_string_1.toDateString)(m[m.length - 1].date), 1));
+            return m.concat([(0, get_date_month_and_year_1.getDateMonthAndYear)(nextDate)]);
         }, months);
     }
     return months;

package/utils/get-months.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMonths = getMonths;
 const create_date_string_1 = require("./create-date-string");
+const date_string_1 = require("./date-string");
 const dayjs_utils_1 = require("./dayjs-utils");
 const get_each_1 = require("./get-each");
 function getMonths({ year, monthLabelFormat = (date) => (0, dayjs_utils_1.dayjsEnWithTz)(date).format("MMMM"), }) {
-    const date = new Date((0, create_date_string_1.createDateString)(year, 0));
-    const yearStart = (0, dayjs_utils_1.dayjsEnWithTz)(date).startOf("year").toDate();
-    const yearEnd = (0, dayjs_utils_1.dayjsEnWithTz)(date).endOf("year").toDate();
-    return (0, get_each_1.getEach)(yearStart, yearEnd, "month").map((d) => ({
-        date: d,
-        monthLabel: monthLabelFormat(d),
-    }));
+    const yearStart = (0, create_date_string_1.createDateString)(year, 0);
+    const yearEnd = (0, create_date_string_1.createDateString)(year, 11);
+    return (0, get_each_1.getEach)(yearStart, yearEnd, "month").map((d) => {
+        const date = (0, date_string_1.fromDateString)(d);
+        return { date, monthLabel: monthLabelFormat(date) };
+    });
 }