@uxf/datepicker 11.111.2 → 11.113.0

package/hooks/use-day.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useDay = useDay;
 const empty_array_1 = require("@uxf/core/constants/empty-array");
 const react_1 = require("react");
-const dayjs_utils_1 = require("../utils/dayjs-utils");
+const date_string_1 = require("../utils/date-string");
 const get_date_invervals_1 = require("../utils/get-date-invervals");
 function useDay({ date, datesConfig, dayRef, focusedDate, isDateBlocked, isDateFocused, isDateHovered, isDateInsideRange, isDateSelected, onDateFocus, onDateHover, onDateSelect, preventScroll, unavailableDates, }) {
     var _a;
@@ -12,7 +12,7 @@ function useDay({ date, datesConfig, dayRef, focusedDate, isDateBlocked, isDateF
     const disabledDates = [...unavailableDates, ...disabledDatesFromConfig].filter((day, index, self) => index === self.findIndex((d) => d.getTime() === day.getTime()));
     const onClick = (0, react_1.useCallback)(() => onDateSelect(date), [date, onDateSelect]);
     const onMouseEnter = (0, react_1.useCallback)(() => onDateHover(date), [date, onDateHover]);
-    const isToday = (0, dayjs_utils_1.dayjsEnWithTz)().isSame(date, "day");
+    const isToday = (0, date_string_1.todayDateString)() === (0, date_string_1.toDateString)(date);
     (0, react_1.useEffect)(() => {
         if (dayRef && dayRef.current && isDateFocused(date)) {
             dayRef.current.focus({
@@ -25,28 +25,29 @@ function useDay({ date, datesConfig, dayRef, focusedDate, isDateBlocked, isDateF
             e.preventDefault();
             switch (e.key) {
                 case "ArrowRight":
-                    onDateFocus((0, dayjs_utils_1.dayjsEnRaw)(date).add(1, "day").toDate());
+                    onDateFocus((0, date_string_1.fromDateString)((0, date_string_1.addDays)((0, date_string_1.toDateString)(date), 1)));
                     break;
                 case "ArrowLeft":
-                    onDateFocus((0, dayjs_utils_1.dayjsEnRaw)(date).subtract(1, "day").toDate());
+                    onDateFocus((0, date_string_1.fromDateString)((0, date_string_1.addDays)((0, date_string_1.toDateString)(date), -1)));
                     break;
                 case "ArrowUp":
-                    onDateFocus((0, dayjs_utils_1.dayjsEnRaw)(date).subtract(7, "day").toDate());
+                    onDateFocus((0, date_string_1.fromDateString)((0, date_string_1.addDays)((0, date_string_1.toDateString)(date), -7)));
                     break;
                 case "ArrowDown":
-                    onDateFocus((0, dayjs_utils_1.dayjsEnRaw)(date).add(7, "day").toDate());
+                    onDateFocus((0, date_string_1.fromDateString)((0, date_string_1.addDays)((0, date_string_1.toDateString)(date), 7)));
                     break;
             }
         }
     }, [date, onDateFocus]);
     const dateIntervals = (0, get_date_invervals_1.getDateIntervals)(disabledDates);
+    const dateStr = (0, date_string_1.toDateString)(date);
     const _isFirstUnavailableDate = () => {
-        return dateIntervals.some((interval) => (0, dayjs_utils_1.dayjsEnRaw)(interval.start).isSame(date, "day"));
+        return dateIntervals.some((interval) => (0, date_string_1.toDateString)(interval.start) === dateStr);
     };
     const _isLastUnavailableDate = () => {
-        return dateIntervals.some((interval) => (0, dayjs_utils_1.dayjsEnRaw)(interval.end).isSame(date, "day"));
+        return dateIntervals.some((interval) => (0, date_string_1.toDateString)(interval.end) === dateStr);
     };
-    const applicableDatesConfigs = datesConfig === null || datesConfig === void 0 ? void 0 : datesConfig.filter((config) => config.dates.some((configDay) => (0, dayjs_utils_1.dayjsEnRaw)(configDay).isSame(date, "day")));
+    const applicableDatesConfigs = datesConfig === null || datesConfig === void 0 ? void 0 : datesConfig.filter((config) => config.dates.some((configDay) => (0, date_string_1.toDateString)(configDay) === dateStr));
     const flags = applicableDatesConfigs === null || applicableDatesConfigs === void 0 ? void 0 : applicableDatesConfigs.reduce((acc, curr) => {
         if (!curr.flag) {
             return acc;
@@ -54,8 +55,8 @@ function useDay({ date, datesConfig, dayRef, focusedDate, isDateBlocked, isDateF
         const intervals = (0, get_date_invervals_1.getDateIntervals)(curr.dates);
         acc.push({
             flag: curr.flag,
-            isFirst: intervals.some((interval) => (0, dayjs_utils_1.dayjsEnRaw)(interval.start).isSame(date, "day")),
-            isLast: intervals.some((interval) => (0, dayjs_utils_1.dayjsEnRaw)(interval.end).isSame(date, "day")),
+            isFirst: intervals.some((interval) => (0, date_string_1.toDateString)(interval.start) === dateStr),
+            isLast: intervals.some((interval) => (0, date_string_1.toDateString)(interval.end) === dateStr),
         });
         return acc;
     }, []);

package/hooks/use-decade.js

@@ -11,12 +11,13 @@ exports.yearLabelFormatFn = yearLabelFormatFn;
 const decadeLabelFormatFn = (start, end) => `${(0, dayjs_utils_1.dayjsEnWithTz)(start).format("YYYY")} \u2013 ${(0, dayjs_utils_1.dayjsEnWithTz)(end).format("YYYY")}`;
 exports.decadeLabelFormatFn = decadeLabelFormatFn;
 function useDecade({ yearLabelFormat = exports.yearLabelFormatFn, decadeLabelFormat = exports.decadeLabelFormatFn, year, }) {
-    const currentYear = new Date((0, create_date_string_1.createDateString)(year, 0));
-    const startYear = (0, dayjs_utils_1.dayjsEnWithTz)(currentYear).subtract(4, "years").startOf("year").toDate();
-    const endYear = (0, dayjs_utils_1.dayjsEnWithTz)(currentYear).add(4, "years").endOf("year").toDate();
-    const years = (0, react_1.useMemo)(() => (0, get_years_1.getYears)({ startYear, endYear, yearLabelFormat }), [endYear, startYear, yearLabelFormat]);
-    return {
-        years,
-        decadeLabel: decadeLabelFormat(startYear, endYear),
-    };
+    const { years, decadeLabel } = (0, react_1.useMemo)(() => {
+        const startYear = new Date((0, create_date_string_1.createDateString)(year - 4, 0));
+        const endYear = new Date((0, create_date_string_1.createDateString)(year + 4, 0));
+        return {
+            years: (0, get_years_1.getYears)({ startYear, endYear, yearLabelFormat }),
+            decadeLabel: decadeLabelFormat(startYear, endYear),
+        };
+    }, [year, yearLabelFormat, decadeLabelFormat]);
+    return { years, decadeLabel };
 }

package/jest.dst.config.js

@@ -0,0 +1,22 @@
+/**
+ * Jest config for DST robustness tests.
+ * Uses America/New_York timezone so that new Date("2026-10-25") (UTC midnight)
+ * resolves to Oct 24 20:00 local time — a different calendar day than new Date(2026, 9, 25).
+ * This exposes timezone bugs where local and UTC calendar days diverge.
+ *
+ * Tests are expected to FAIL until the DateString refactor (Tasks 2–10) is complete.
+ */
+
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+    preset: "ts-jest",
+    // "node" overrides the project-wide jsdom default (set in root jest.config.js via ts-jest preset).
+    // DST tests must run in node environment — jsdom swallows timezone behaviour.
+    testEnvironment: "node",
+    globalSetup: "<rootDir>/jest.dst.global-setup.js",
+    rootDir: ".",
+    testMatch: ["<rootDir>/utils/dst-robustness.test.ts"],
+    transform: {
+        "\\.[t]sx?$": ["ts-jest", { diagnostics: false }],
+    },
+};

package/jest.dst.global-setup.js

@@ -0,0 +1,14 @@
+/**
+ * Custom globalSetup for DST robustness tests.
+ *
+ * Belt-and-suspenders reinforcement: the npm scripts (test:dst, test:tz:ny, test:tz:prague)
+ * already set TZ=... as an env prefix before Node starts, which is the reliable way to
+ * set the timezone. This file re-asserts the TZ for America/New_York as a fallback in case
+ * the config is ever invoked without the env prefix (e.g. direct `jest --config=...` call).
+ *
+ * Note: the monorepo root global-setup.js sets TZ=UTC, but it only runs when Jest is
+ * invoked via the root jest.config.js. This custom globalSetup overrides that for DST tests.
+ */
+module.exports = async () => {
+    process.env.TZ = process.env.TZ || "America/New_York";
+};

package/package.json

@@ -1,11 +1,16 @@
 {
     "name": "@uxf/datepicker",
-    "version": "11.111.2",
+    "version": "11.113.0",
     "description": "A set of React hooks to create an awesome datepicker.",
     "main": "index.js",
     "scripts": {
         "build": "tsc -P tsconfig.json",
-        "typecheck": "tsc --noEmit --skipLibCheck"
+        "typecheck": "tsc --noEmit --skipLibCheck",
+        "test:tz:prague": "TZ=Europe/Prague jest --config=jest.dst.config.js --no-coverage",
+        "test:tz:ny": "TZ=America/New_York jest --config=jest.dst.config.js --no-coverage",
+        "test:tz:tokyo": "TZ=Asia/Tokyo jest --config=jest.dst.config.js --no-coverage",
+        "test:dst": "TZ=America/New_York jest --config=jest.dst.config.js --no-coverage",
+        "test:tz": "npm run test:tz:prague && npm run test:tz:ny && npm run test:tz:tokyo"
     },
     "publishConfig": {
         "access": "public"

package/utils/can-select-range.d.ts

@@ -1,10 +1,11 @@
+import { DateString } from "@uxf/core/date";
 export interface CanSelectRangeProps {
-    startDate: Date;
-    endDate: Date | null;
-    isDateBlocked: ((date: Date) => boolean) | null;
+    startDate: DateString;
+    endDate: DateString | null;
+    isDateBlocked: ((date: DateString) => boolean) | null;
     minBookingDays: number;
     exactMinBookingDays?: boolean;
-    minBookingDate?: Date;
-    maxBookingDate?: Date;
+    minBookingDate?: DateString;
+    maxBookingDate?: DateString;
 }
 export declare function canSelectRange({ startDate, endDate, isDateBlocked, minBookingDays, exactMinBookingDays, minBookingDate, maxBookingDate, }: CanSelectRangeProps): boolean;

package/utils/can-select-range.js

@@ -1,23 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canSelectRange = canSelectRange;
-const dayjs_utils_1 = require("./dayjs-utils");
+const date_string_1 = require("./date-string");
 const get_each_1 = require("./get-each");
 // eslint-disable-next-line complexity
 function canSelectRange({ startDate, endDate, isDateBlocked, minBookingDays, exactMinBookingDays, minBookingDate, maxBookingDate, }) {
-    const isStartDateAfterOrEqualMinDate = minBookingDate
-        ? !(0, dayjs_utils_1.dayjsEnRaw)(startDate).isBefore((0, dayjs_utils_1.dayjsEnRaw)(minBookingDate).subtract(1, "day"))
-        : true;
+    const isStartDateAfterOrEqualMinDate = minBookingDate ? startDate >= (0, date_string_1.addDays)(minBookingDate, -1) : true;
     const isStartDateBeforeOrEqualMaxDate = maxBookingDate
-        ? !(0, dayjs_utils_1.dayjsEnRaw)(startDate)
-            .add(minBookingDays - 1, "day")
-            .isAfter(maxBookingDate)
-        : true;
-    const isEndDatBeforeOrEqualMaxDate = maxBookingDate
-        ? !(0, dayjs_utils_1.dayjsEnRaw)(endDate)
-            .add(minBookingDays - 1, "day")
-            .isAfter(maxBookingDate)
+        ? (0, date_string_1.addDays)(startDate, minBookingDays - 1) <= maxBookingDate
         : true;
+    const isEndDatBeforeOrEqualMaxDate = maxBookingDate && endDate ? (0, date_string_1.addDays)(endDate, minBookingDays - 1) <= maxBookingDate : true;
     if (!isStartDateAfterOrEqualMinDate || !isStartDateBeforeOrEqualMaxDate || !isEndDatBeforeOrEqualMaxDate) {
         return false;
     }
@@ -30,15 +22,11 @@ function canSelectRange({ startDate, endDate, isDateBlocked, minBookingDays, exa
         if (!isDateBlocked) {
             return true;
         }
-        return !(0, get_each_1.getEach)(startDate, (0, dayjs_utils_1.dayjsEnRaw)(startDate)
-            .add(minBookingDays - 1, "day")
-            .toDate(), "day").some(isDateBlocked);
+        return !(0, get_each_1.getEach)(startDate, (0, date_string_1.addDays)(startDate, minBookingDays - 1), "day").some(isDateBlocked);
     }
     else if (endDate && !exactMinBookingDays) {
-        const minBookingDaysDate = (0, dayjs_utils_1.dayjsEnWithTz)(startDate)
-            .add(minBookingDays - 1, "day")
-            .toDate();
-        if ((0, dayjs_utils_1.dayjsEnWithTz)(endDate).isBefore(minBookingDaysDate)) {
+        const minBookingDaysDate = (0, date_string_1.addDays)(startDate, minBookingDays - 1);
+        if (endDate < minBookingDaysDate) {
             return false;
         }
         if (!isDateBlocked) {

package/utils/can-select-range.test.js

@@ -4,7 +4,7 @@ const can_select_range_1 = require("./can-select-range");
 test("canSelectRange", () => {
     // start day only
     expect((0, can_select_range_1.canSelectRange)({
-        startDate: new Date("2021-08-08"),
+        startDate: "2021-08-08",
         endDate: null,
         minBookingDays: 1,
         minBookingDate: undefined,
@@ -14,8 +14,8 @@ test("canSelectRange", () => {
     })).toBe(true);
     // start and end date
     expect((0, can_select_range_1.canSelectRange)({
-        startDate: new Date("2021-08-08"),
-        endDate: new Date("2021-08-08"),
+        startDate: "2021-08-08",
+        endDate: "2021-08-08",
         minBookingDays: 1,
         minBookingDate: undefined,
         maxBookingDate: undefined,
@@ -24,18 +24,8 @@ test("canSelectRange", () => {
     })).toBe(true);
     // minBookingDays longer than range
     expect((0, can_select_range_1.canSelectRange)({
-        startDate: new Date("2021-08-08"),
-        endDate: new Date("2021-08-08"),
-        minBookingDays: 2,
-        minBookingDate: undefined,
-        maxBookingDate: undefined,
-        exactMinBookingDays: false,
-        isDateBlocked: () => false,
-    })).toBe(false);
-    // minBookingDays longer than range
-    expect((0, can_select_range_1.canSelectRange)({
-        startDate: new Date("2021-08-08"),
-        endDate: new Date("2021-08-08"),
+        startDate: "2021-08-08",
+        endDate: "2021-08-08",
         minBookingDays: 2,
         minBookingDate: undefined,
         maxBookingDate: undefined,
@@ -44,8 +34,8 @@ test("canSelectRange", () => {
     })).toBe(false);
     // blocked date
     expect((0, can_select_range_1.canSelectRange)({
-        startDate: new Date("2021-08-08"),
-        endDate: new Date("2021-08-08"),
+        startDate: "2021-08-08",
+        endDate: "2021-08-08",
         minBookingDays: 1,
         minBookingDate: undefined,
         maxBookingDate: undefined,
@@ -54,37 +44,50 @@ test("canSelectRange", () => {
     })).toBe(false);
     // before minBookingDate
     expect((0, can_select_range_1.canSelectRange)({
-        startDate: new Date("2021-08-05"),
-        endDate: new Date("2021-08-12"),
+        startDate: "2021-08-05",
+        endDate: "2021-08-12",
         minBookingDays: 1,
-        minBookingDate: new Date("2021-08-10"),
+        minBookingDate: "2021-08-10",
         maxBookingDate: undefined,
         exactMinBookingDays: false,
         isDateBlocked: () => false,
     })).toBe(false);
     // after maxBookingDate
     expect((0, can_select_range_1.canSelectRange)({
-        startDate: new Date("2021-08-01"),
-        endDate: new Date("2021-08-08"),
+        startDate: "2021-08-01",
+        endDate: "2021-08-08",
         minBookingDays: 1,
         minBookingDate: undefined,
-        maxBookingDate: new Date("2021-08-06"),
+        maxBookingDate: "2021-08-06",
         exactMinBookingDays: false,
         isDateBlocked: () => false,
     })).toBe(false);
     // exactMinBookingDays
     expect((0, can_select_range_1.canSelectRange)({
-        startDate: new Date("2021-08-01"),
-        endDate: new Date("2021-08-08"),
+        startDate: "2021-08-01",
+        endDate: "2021-08-08",
         minBookingDays: 8,
         minBookingDate: undefined,
         maxBookingDate: undefined,
         exactMinBookingDays: true,
         isDateBlocked: () => false,
     })).toBe(true);
+});
+test("canSelectRange DST fall-back (Oct 25 2026)", () => {
+    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("canSelectRange DST spring-forward (Mar 29 2026)", () => {
     expect((0, can_select_range_1.canSelectRange)({
-        startDate: new Date("2026-10-25"),
-        endDate: new Date("2026-10-26"),
+        startDate: "2026-03-29",
+        endDate: "2026-03-30",
         minBookingDays: 2,
         minBookingDate: undefined,
         maxBookingDate: undefined,

package/utils/date-string.d.ts

@@ -0,0 +1,34 @@
+import { DateString } from "@uxf/core/date";
+/**
+ * Convert a Date to a zero-padded DateString.
+ *
+ * Handles both creation styles correctly:
+ *  - new Date("2026-10-25")   → ISO string → UTC midnight → use UTC methods
+ *  - new Date(2026, 9, 25)    → local constructor → use local methods
+ *
+ * The heuristic: if all UTC time components are zero the date was parsed from
+ * an ISO date string (UTC midnight convention); otherwise it came from a local
+ * constructor and local methods give the correct calendar day.
+ */
+export declare function toDateString(date: Date): DateString;
+/**
+ * Convert a DateString back to a Date at UTC midnight.
+ */
+export declare function fromDateString(s: DateString): Date;
+/**
+ * Today as a DateString in UTC — matches the `new Date("Y-M-D")` convention
+ * used throughout the package. Use this instead of `toDateString(new Date())`
+ * whenever you need a stable "today" string.
+ */
+export declare function todayDateString(): DateString;
+/**
+ * Add n calendar months to a DateString, snapping to the 1st of the resulting month.
+ * Month arithmetic is purely numeric — no DST exposure.
+ */
+export declare function addMonths(date: DateString, n: number): DateString;
+/**
+ * Add n calendar days to a DateString.
+ * Uses UTC midnight arithmetic — UTC has no DST, so adding DAY_MS is always correct.
+ * Pass negative n to subtract days.
+ */
+export declare function addDays(date: DateString, n: number): DateString;

package/utils/date-string.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDateString = toDateString;
+exports.fromDateString = fromDateString;
+exports.todayDateString = todayDateString;
+exports.addMonths = addMonths;
+exports.addDays = addDays;
+const create_date_string_1 = require("./create-date-string");
+const DAY_MS = 86400000;
+/**
+ * Convert a Date to a zero-padded DateString.
+ *
+ * Handles both creation styles correctly:
+ *  - new Date("2026-10-25")   → ISO string → UTC midnight → use UTC methods
+ *  - new Date(2026, 9, 25)    → local constructor → use local methods
+ *
+ * The heuristic: if all UTC time components are zero the date was parsed from
+ * an ISO date string (UTC midnight convention); otherwise it came from a local
+ * constructor and local methods give the correct calendar day.
+ */
+function toDateString(date) {
+    if (date.getUTCHours() === 0 &&
+        date.getUTCMinutes() === 0 &&
+        date.getUTCSeconds() === 0 &&
+        date.getUTCMilliseconds() === 0) {
+        return (0, create_date_string_1.createDateString)(date.getUTCFullYear(), date.getUTCMonth(), // 0-indexed; createDateString adds 1
+        date.getUTCDate());
+    }
+    return (0, create_date_string_1.createDateString)(date.getFullYear(), date.getMonth(), // 0-indexed; createDateString adds 1
+    date.getDate());
+}
+/**
+ * Convert a DateString back to a Date at UTC midnight.
+ */
+function fromDateString(s) {
+    return new Date(s);
+}
+/**
+ * Today as a DateString in UTC — matches the `new Date("Y-M-D")` convention
+ * used throughout the package. Use this instead of `toDateString(new Date())`
+ * whenever you need a stable "today" string.
+ */
+function todayDateString() {
+    const now = new Date();
+    return (0, create_date_string_1.createDateString)(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+}
+/**
+ * Add n calendar months to a DateString, snapping to the 1st of the resulting month.
+ * Month arithmetic is purely numeric — no DST exposure.
+ */
+function addMonths(date, n) {
+    const y = parseInt(date.slice(0, 4), 10);
+    const m = parseInt(date.slice(5, 7), 10) - 1; // 0-indexed
+    const total = y * 12 + m + n;
+    return (0, create_date_string_1.createDateString)(Math.floor(total / 12), total % 12);
+}
+/**
+ * Add n calendar days to a DateString.
+ * Uses UTC midnight arithmetic — UTC has no DST, so adding DAY_MS is always correct.
+ * Pass negative n to subtract days.
+ */
+function addDays(date, n) {
+    return toDateString(new Date(new Date(date).getTime() + n * DAY_MS));
+}

package/utils/date-string.test.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/date-string.test.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const date_string_1 = require("./date-string");
+test("toDateString reads UTC date components from ISO-string Date", () => {
+    expect((0, date_string_1.toDateString)(new Date("2026-10-25T00:00:00Z"))).toBe("2026-10-25");
+    expect((0, date_string_1.toDateString)(new Date("2026-03-29T00:00:00Z"))).toBe("2026-03-29");
+    expect((0, date_string_1.toDateString)(new Date("2021-01-01T00:00:00Z"))).toBe("2021-01-01");
+});
+test("toDateString reads local date components from local-constructor Date", () => {
+    // new Date(y, m, d) creates local midnight — must give same DateString as ISO string
+    expect((0, date_string_1.toDateString)(new Date(2026, 9, 25))).toBe("2026-10-25");
+    expect((0, date_string_1.toDateString)(new Date(2026, 2, 29))).toBe("2026-03-29");
+    expect((0, date_string_1.toDateString)(new Date(2025, 11, 31))).toBe("2025-12-31");
+    expect((0, date_string_1.toDateString)(new Date(2026, 0, 1))).toBe("2026-01-01");
+});
+test("toDateString: ISO string and local constructor give the same DateString for the same calendar day", () => {
+    expect((0, date_string_1.toDateString)(new Date(2026, 9, 25))).toBe((0, date_string_1.toDateString)(new Date("2026-10-25")));
+    expect((0, date_string_1.toDateString)(new Date(2025, 11, 31))).toBe((0, date_string_1.toDateString)(new Date("2025-12-31")));
+    expect((0, date_string_1.toDateString)(new Date(2026, 0, 1))).toBe((0, date_string_1.toDateString)(new Date("2026-01-01")));
+});
+test("toDateString zero-pads month and day", () => {
+    expect((0, date_string_1.toDateString)(new Date(Date.UTC(2021, 0, 5)))).toBe("2021-01-05");
+    expect((0, date_string_1.toDateString)(new Date(Date.UTC(2021, 8, 3)))).toBe("2021-09-03");
+});
+test("fromDateString returns UTC midnight Date", () => {
+    const d = (0, date_string_1.fromDateString)("2026-10-25");
+    expect(d.getUTCFullYear()).toBe(2026);
+    expect(d.getUTCMonth()).toBe(9);
+    expect(d.getUTCDate()).toBe(25);
+    expect(d.getUTCHours()).toBe(0);
+    expect(d.getUTCMinutes()).toBe(0);
+});
+test("toDateString and fromDateString are inverses", () => {
+    const s = "2026-10-25";
+    expect((0, date_string_1.toDateString)((0, date_string_1.fromDateString)(s))).toBe(s);
+});
+test("addDays adds calendar days across DST fall-back (Oct 25 2026)", () => {
+    expect((0, date_string_1.addDays)("2026-10-24", 1)).toBe("2026-10-25");
+    expect((0, date_string_1.addDays)("2026-10-25", 1)).toBe("2026-10-26");
+});
+test("addDays adds calendar days across DST spring-forward (Mar 29 2026)", () => {
+    expect((0, date_string_1.addDays)("2026-03-28", 1)).toBe("2026-03-29");
+    expect((0, date_string_1.addDays)("2026-03-29", 1)).toBe("2026-03-30");
+});
+test("addDays with negative n subtracts days", () => {
+    expect((0, date_string_1.addDays)("2026-10-25", -1)).toBe("2026-10-24");
+    expect((0, date_string_1.addDays)("2026-10-01", -1)).toBe("2026-09-30");
+});
+test("addDays with n=0 returns same date", () => {
+    expect((0, date_string_1.addDays)("2026-10-25", 0)).toBe("2026-10-25");
+});
+test("addMonths advances by positive months", () => {
+    expect((0, date_string_1.addMonths)("2026-04-01", 1)).toBe("2026-05-01");
+    expect((0, date_string_1.addMonths)("2026-11-01", 2)).toBe("2027-01-01");
+    expect((0, date_string_1.addMonths)("2026-04-15", 1)).toBe("2026-05-01");
+});
+test("addMonths goes back with negative months", () => {
+    expect((0, date_string_1.addMonths)("2026-03-01", -1)).toBe("2026-02-01");
+    expect((0, date_string_1.addMonths)("2026-01-01", -1)).toBe("2025-12-01");
+});
+test("addMonths with n=0 returns first of same month", () => {
+    expect((0, date_string_1.addMonths)("2026-04-15", 0)).toBe("2026-04-01");
+});

package/utils/dayjs-utils.d.ts

@@ -1,4 +1,3 @@
 import dayjs, { ConfigType } from "dayjs";
 import "dayjs/locale/en";
-export declare const dayjsEnRaw: (value?: ConfigType) => dayjs.Dayjs;
 export declare const dayjsEnWithTz: (value?: ConfigType, tz?: string) => dayjs.Dayjs;

package/utils/dayjs-utils.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dayjsEnWithTz = exports.dayjsEnRaw = void 0;
+exports.dayjsEnWithTz = void 0;
 const dayjs_1 = __importStar(require("dayjs"));
 require("dayjs/locale/en");
 const isBetween_1 = __importDefault(require("dayjs/plugin/isBetween"));
@@ -45,10 +45,6 @@ const utc_1 = __importDefault(require("dayjs/plugin/utc"));
 (0, dayjs_1.extend)(isBetween_1.default);
 (0, dayjs_1.extend)(timezone_1.default);
 (0, dayjs_1.extend)(utc_1.default);
-const dayjsEnRaw = (value) => {
-    return (0, dayjs_1.default)(value).locale("en");
-};
-exports.dayjsEnRaw = dayjsEnRaw;
 const dayjsEnWithTz = (value, tz = "UTC") => {
     return (0, dayjs_1.default)(value).tz(tz).locale("en");
 };

package/utils/dst-robustness.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export {};