@uxf/datepicker 11.111.2 → 11.113.0

package/utils/get-next-active-month.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNextActiveMonth = getNextActiveMonth;
-const dayjs_utils_1 = require("./dayjs-utils");
+const date_string_1 = require("./date-string");
 const get_date_month_and_year_1 = require("./get-date-month-and-year");
 function getNextActiveMonth(activeMonth, numberOfMonths, counter, step) {
     let prevMonth;
@@ -11,19 +11,15 @@ function getNextActiveMonth(activeMonth, numberOfMonths, counter, step) {
     else {
         prevMonth = counter > 0 ? activeMonth.length - 1 : 0;
     }
-    let prevMonthDate = activeMonth[prevMonth].date;
+    let prevMonthStr = (0, date_string_1.toDateString)(activeMonth[prevMonth].date);
     return Array.from(Array(numberOfMonths).keys()).reduce((m) => {
         if (m.length === 0) {
-            prevMonthDate = (0, dayjs_utils_1.dayjsEnWithTz)(prevMonthDate).add(counter, "month").startOf("month").toDate();
+            prevMonthStr = (0, date_string_1.addMonths)(prevMonthStr, counter);
         }
         else {
-            prevMonthDate = (0, dayjs_utils_1.dayjsEnWithTz)(prevMonthDate)
-                .add(counter >= 0 ? 1 : -1, "month")
-                .startOf("month")
-                .toDate();
+            prevMonthStr = (0, date_string_1.addMonths)(prevMonthStr, counter >= 0 ? 1 : -1);
         }
-        return counter > 0
-            ? m.concat([(0, get_date_month_and_year_1.getDateMonthAndYear)(prevMonthDate)])
-            : [(0, get_date_month_and_year_1.getDateMonthAndYear)(prevMonthDate)].concat(m);
+        const monthType = (0, get_date_month_and_year_1.getDateMonthAndYear)(new Date(prevMonthStr));
+        return counter > 0 ? m.concat([monthType]) : [monthType].concat(m);
     }, []);
 }

package/utils/get-weekday-labels.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWeekdayLabels = getWeekdayLabels;
+const date_string_1 = require("./date-string");
 const dayjs_utils_1 = require("./dayjs-utils");
 const get_each_1 = require("./get-each");
 function getWeekdayLabels({ firstDayOfWeek = 0, weekdayLabelFormat = (date) => (0, dayjs_utils_1.dayjsEnWithTz)(date).format("dd"), }) {
     const now = (0, dayjs_utils_1.dayjsEnWithTz)();
-    const arr = (0, get_each_1.getEach)(now.startOf("week").add(firstDayOfWeek, "day").toDate(), now.endOf("week").add(firstDayOfWeek, "day").toDate(), "day");
-    return arr.map((date) => weekdayLabelFormat(date));
+    const start = now.startOf("week").add(firstDayOfWeek, "day").format("YYYY-MM-DD");
+    const end = now.endOf("week").add(firstDayOfWeek, "day").format("YYYY-MM-DD");
+    return (0, get_each_1.getEach)(start, end, "day").map((d) => weekdayLabelFormat((0, date_string_1.fromDateString)(d)));
 }

package/utils/get-years.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getYears = getYears;
+const date_string_1 = require("./date-string");
 const dayjs_utils_1 = require("./dayjs-utils");
 const get_each_1 = require("./get-each");
 function getYears({ startYear, endYear, yearLabelFormat = (date) => (0, dayjs_utils_1.dayjsEnWithTz)(date).format("YYYY"), }) {
-    return (0, get_each_1.getEach)(startYear, endYear, "year").map((d) => ({
-        date: d,
-        yearLabel: yearLabelFormat(d),
-    }));
+    return (0, get_each_1.getEach)((0, date_string_1.toDateString)(startYear), (0, date_string_1.toDateString)(endYear), "year").map((d) => {
+        const date = (0, date_string_1.fromDateString)(d);
+        return { date, yearLabel: yearLabelFormat(date) };
+    });
 }

package/utils/is-date-blocked.d.ts

@@ -1,12 +1,13 @@
+import { DateString } from "@uxf/core/date";
 interface IsDateBlockedProps {
-    date: Date;
-    startDate: Date | null;
-    endDate: Date | null;
+    date: DateString;
+    startDate: DateString | null;
+    endDate: DateString | null;
     minBookingDays?: number;
-    minBookingDate?: Date;
-    maxBookingDate?: Date;
+    minBookingDate?: DateString;
+    maxBookingDate?: DateString;
     isDateBlockedFn?: ((date: Date) => boolean) | null;
-    unavailableDates?: Date[];
+    unavailableDates?: DateString[];
 }
 export declare function isDateBlocked({ date, minBookingDate, maxBookingDate, isDateBlockedFn, startDate, endDate, minBookingDays, unavailableDates, }: IsDateBlockedProps): boolean;
 export {};

package/utils/is-date-blocked.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDateBlocked = isDateBlocked;
-const dayjs_utils_1 = require("./dayjs-utils");
+const date_string_1 = require("./date-string");
 const is_in_unavailable_dates_1 = require("./is-in-unavailable-dates");
 function isDateBlocked({ date, minBookingDate, maxBookingDate, isDateBlockedFn, startDate, endDate, minBookingDays = 1, unavailableDates = [], }) {
-    const compareMinDate = minBookingDate;
-    const compareMaxDate = maxBookingDate;
     return Boolean((0, is_in_unavailable_dates_1.isInUnavailableDates)(unavailableDates, date) ||
-        (compareMinDate && date < compareMinDate) ||
-        (compareMaxDate && date > compareMaxDate) ||
+        (minBookingDate && date < minBookingDate) ||
+        (maxBookingDate && date > maxBookingDate) ||
         (startDate &&
             !endDate &&
             minBookingDays > 1 &&
-            (0, dayjs_utils_1.dayjsEnWithTz)(date).isBetween(startDate, (0, dayjs_utils_1.dayjsEnWithTz)(startDate).add(minBookingDays - 1, "day"))) ||
-        (isDateBlockedFn && isDateBlockedFn(date)));
+            date > startDate &&
+            date < (0, date_string_1.addDays)(startDate, minBookingDays - 1)) ||
+        (isDateBlockedFn && isDateBlockedFn((0, date_string_1.fromDateString)(date))));
 }

package/utils/is-date-blocked.test.js

@@ -4,23 +4,23 @@ const is_date_blocked_1 = require("./is-date-blocked");
 test("isDateBlocked", () => {
     // custom fn
     expect((0, is_date_blocked_1.isDateBlocked)({
-        startDate: new Date("2021-08-08"),
+        startDate: "2021-08-08",
         endDate: null,
         minBookingDays: 1,
         minBookingDate: undefined,
         maxBookingDate: undefined,
-        date: new Date("2021-08-08"),
+        date: "2021-08-08",
         unavailableDates: undefined,
         isDateBlockedFn: () => true,
     })).toBe(true);
-    // start day only
+    // not blocked
     expect((0, is_date_blocked_1.isDateBlocked)({
-        startDate: new Date("2021-08-08"),
+        startDate: "2021-08-08",
         endDate: null,
         minBookingDays: 1,
         minBookingDate: undefined,
         maxBookingDate: undefined,
-        date: new Date("2021-08-08"),
+        date: "2021-08-08",
         unavailableDates: undefined,
         isDateBlockedFn: undefined,
     })).toBe(false);
@@ -29,9 +29,9 @@ test("isDateBlocked", () => {
         startDate: null,
         endDate: null,
         minBookingDays: 1,
-        minBookingDate: new Date("2021-08-10"),
+        minBookingDate: "2021-08-10",
         maxBookingDate: undefined,
-        date: new Date("2021-08-08"),
+        date: "2021-08-08",
         unavailableDates: undefined,
         isDateBlockedFn: undefined,
     })).toBe(true);
@@ -41,8 +41,8 @@ test("isDateBlocked", () => {
         endDate: null,
         minBookingDays: 1,
         minBookingDate: undefined,
-        maxBookingDate: new Date("2021-08-06"),
-        date: new Date("2021-08-08"),
+        maxBookingDate: "2021-08-06",
+        date: "2021-08-08",
         unavailableDates: undefined,
         isDateBlockedFn: undefined,
     })).toBe(true);
@@ -53,8 +53,105 @@ test("isDateBlocked", () => {
         minBookingDays: 1,
         minBookingDate: undefined,
         maxBookingDate: undefined,
-        date: new Date("2021-08-08"),
-        unavailableDates: [new Date("2021-08-08")],
+        date: "2021-08-08",
+        unavailableDates: ["2021-08-08"],
         isDateBlockedFn: undefined,
     })).toBe(true);
 });
+test("isDateBlocked minBookingDays boundary", () => {
+    // minBookingDays=1 (default) — never blocks on the between-dates condition
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: "2026-01-01",
+        endDate: null,
+        minBookingDays: 1,
+        date: "2026-01-02",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(false);
+    // minBookingDays=2 — blocks nothing between startDate and startDate+1 (empty set)
+    // "2026-01-01" < date < "2026-01-02" has no whole-day solution, so nothing is blocked.
+    // Minimum valid endDate is startDate+1 = "2026-01-02" (2-day booking). Correct.
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: "2026-01-01",
+        endDate: null,
+        minBookingDays: 2,
+        date: "2026-01-02",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(false);
+    // minBookingDays=3 — blocks startDate+1 only; startDate+2 is the first valid endDate (3-day booking)
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: "2026-01-01",
+        endDate: null,
+        minBookingDays: 3,
+        date: "2026-01-02",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(true);
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: "2026-01-01",
+        endDate: null,
+        minBookingDays: 3,
+        date: "2026-01-03",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(false);
+    // minBookingDays=4 — blocks startDate+1 and startDate+2; startDate+3 is the first valid endDate
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: "2026-01-01",
+        endDate: null,
+        minBookingDays: 4,
+        date: "2026-01-02",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(true);
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: "2026-01-01",
+        endDate: null,
+        minBookingDays: 4,
+        date: "2026-01-03",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(true);
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: "2026-01-01",
+        endDate: null,
+        minBookingDays: 4,
+        date: "2026-01-04",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(false);
+    // minBookingDays condition is inactive once endDate is set
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: "2026-01-01",
+        endDate: "2026-01-05",
+        minBookingDays: 4,
+        date: "2026-01-02",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(false);
+});
+test("isDateBlocked DST boundary", () => {
+    // date on fall-back day is blocked by minBookingDate on next day
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: null,
+        endDate: null,
+        minBookingDays: 1,
+        minBookingDate: "2026-10-26",
+        maxBookingDate: undefined,
+        date: "2026-10-25",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(true);
+    // date on fall-back day is NOT blocked when it equals minBookingDate
+    expect((0, is_date_blocked_1.isDateBlocked)({
+        startDate: null,
+        endDate: null,
+        minBookingDays: 1,
+        minBookingDate: "2026-10-25",
+        maxBookingDate: undefined,
+        date: "2026-10-25",
+        unavailableDates: undefined,
+        isDateBlockedFn: undefined,
+    })).toBe(false);
+});

package/utils/is-date-hovered.d.ts

@@ -1,9 +1,10 @@
+import { DateString } from "@uxf/core/date";
 export interface IsDateHoveredProps {
-    startDate: Date | null;
-    endDate: Date | null;
-    date: Date;
-    isDateBlocked: ((date: Date) => boolean) | null;
-    hoveredDate: Date | null;
+    startDate: DateString | null;
+    endDate: DateString | null;
+    date: DateString;
+    isDateBlocked: ((date: DateString) => boolean) | null;
+    hoveredDate: DateString | null;
     minBookingDays: number;
     exactMinBookingDays: boolean;
 }

package/utils/is-date-hovered.js

@@ -1,48 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDateHovered = isDateHovered;
-const dayjs_utils_1 = require("./dayjs-utils");
+const date_string_1 = require("./date-string");
 const get_each_1 = require("./get-each");
+function isRangeUnblocked(start, end, isDateBlocked) {
+    return !isDateBlocked || !(0, get_each_1.getEach)(start, end, "day").some(isDateBlocked);
+}
 function isDateHovered({ date, startDate, endDate, isDateBlocked, hoveredDate, minBookingDays, exactMinBookingDays, }) {
     if (
     // exact min booking days
     hoveredDate &&
         minBookingDays > 1 &&
         exactMinBookingDays &&
-        (0, dayjs_utils_1.dayjsEnRaw)(date).isBetween(hoveredDate, (0, dayjs_utils_1.dayjsEnRaw)(hoveredDate).add(minBookingDays - 1, "day"))) {
-        if (!isDateBlocked) {
-            return true;
-        }
-        return !(0, get_each_1.getEach)(hoveredDate, (0, dayjs_utils_1.dayjsEnRaw)(hoveredDate)
-            .add(minBookingDays - 1, "day")
-            .toDate(), "day").some((d) => isDateBlocked(d));
+        date > hoveredDate &&
+        date < (0, date_string_1.addDays)(hoveredDate, minBookingDays - 1)) {
+        return isRangeUnblocked(hoveredDate, (0, date_string_1.addDays)(hoveredDate, minBookingDays - 1), isDateBlocked);
     }
     else if (
-    // min booking days
+    // min booking days (start date hovered)
     startDate &&
         !endDate &&
         hoveredDate &&
-        (0, dayjs_utils_1.dayjsEnRaw)(date).isBetween(startDate, (0, dayjs_utils_1.dayjsEnRaw)(startDate).add(minBookingDays - 1, "day")) &&
-        (0, dayjs_utils_1.dayjsEnRaw)(startDate).isSame(hoveredDate, "days") &&
+        date > startDate &&
+        date < (0, date_string_1.addDays)(startDate, minBookingDays - 1) &&
+        startDate === hoveredDate &&
         minBookingDays > 1) {
-        if (!isDateBlocked) {
-            return true;
-        }
-        return !(0, get_each_1.getEach)(startDate, (0, dayjs_utils_1.dayjsEnRaw)(startDate)
-            .add(minBookingDays - 1, "day")
-            .toDate(), "day").some((d) => isDateBlocked(d));
+        return isRangeUnblocked(startDate, (0, date_string_1.addDays)(startDate, minBookingDays - 1), isDateBlocked);
     }
     else if (
-    // normal
+    // normal hover range
     startDate &&
         !endDate &&
         hoveredDate &&
-        !(0, dayjs_utils_1.dayjsEnRaw)(hoveredDate).isBefore(startDate) &&
-        (0, dayjs_utils_1.dayjsEnRaw)(date).isBetween(startDate, hoveredDate)) {
-        if (!isDateBlocked) {
-            return true;
-        }
-        return !(0, get_each_1.getEach)(startDate, hoveredDate, "day").some((d) => isDateBlocked(d));
+        hoveredDate >= startDate &&
+        date > startDate &&
+        date < hoveredDate) {
+        return isRangeUnblocked(startDate, hoveredDate, isDateBlocked);
     }
     return false;
 }

package/utils/is-date-hovered.test.js

@@ -1,72 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_date_hovered_1 = require("./is-date-hovered");
-test("isDateHovered", () => {
-    // exact min booking days
+test("isDateHovered — exact min booking days", () => {
+    // date within exact range but blocked
     expect((0, is_date_hovered_1.isDateHovered)({
         startDate: null,
         endDate: null,
         minBookingDays: 5,
-        date: new Date("2021-08-08"),
-        hoveredDate: new Date("2021-08-07"),
+        date: "2021-08-08",
+        hoveredDate: "2021-08-07",
         exactMinBookingDays: true,
         isDateBlocked: () => true,
     })).toBe(false);
+    // date within exact range, not blocked
     expect((0, is_date_hovered_1.isDateHovered)({
         startDate: null,
         endDate: null,
         minBookingDays: 5,
-        date: new Date("2021-08-08"),
-        hoveredDate: new Date("2021-08-07"),
+        date: "2021-08-08",
+        hoveredDate: "2021-08-07",
         exactMinBookingDays: true,
         isDateBlocked: () => false,
     })).toBe(true);
-    // min booking days
+});
+test("isDateHovered — min booking days", () => {
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: new Date("2021-08-07"),
+        startDate: "2021-08-07",
         endDate: null,
         minBookingDays: 5,
-        date: new Date("2021-08-08"),
-        hoveredDate: new Date("2021-08-07"),
+        date: "2021-08-08",
+        hoveredDate: "2021-08-07",
         exactMinBookingDays: false,
         isDateBlocked: () => true,
     })).toBe(false);
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: new Date("2021-08-07"),
+        startDate: "2021-08-07",
         endDate: null,
         minBookingDays: 5,
-        date: new Date("2021-08-08"),
-        hoveredDate: new Date("2021-08-07"),
+        date: "2021-08-08",
+        hoveredDate: "2021-08-07",
         exactMinBookingDays: false,
         isDateBlocked: () => false,
     })).toBe(true);
-    // normal
+});
+test("isDateHovered — normal hover range", () => {
+    // blocked
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: new Date("2021-08-07"),
+        startDate: "2021-08-07",
         endDate: null,
         minBookingDays: 1,
-        date: new Date("2021-08-08"),
-        hoveredDate: new Date("2021-08-09"),
+        date: "2021-08-08",
+        hoveredDate: "2021-08-09",
         exactMinBookingDays: false,
         isDateBlocked: () => true,
     })).toBe(false);
+    // not blocked
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: new Date("2021-08-07"),
+        startDate: "2021-08-07",
         endDate: null,
         minBookingDays: 1,
-        date: new Date("2021-08-08"),
-        hoveredDate: new Date("2021-08-09"),
+        date: "2021-08-08",
+        hoveredDate: "2021-08-09",
         exactMinBookingDays: false,
         isDateBlocked: () => false,
     })).toBe(true);
-    // with endDate
+});
+test("isDateHovered — with endDate returns false", () => {
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: new Date("2021-08-07"),
-        endDate: new Date("2021-08-12"),
+        startDate: "2021-08-07",
+        endDate: "2021-08-12",
         minBookingDays: 1,
-        date: new Date("2021-08-08"),
-        hoveredDate: new Date("2021-08-07"),
+        date: "2021-08-08",
+        hoveredDate: "2021-08-07",
         exactMinBookingDays: false,
         isDateBlocked: () => true,
     })).toBe(false);
 });
+test("isDateHovered — DST fall-back boundary", () => {
+    expect((0, is_date_hovered_1.isDateHovered)({
+        startDate: "2026-10-24",
+        endDate: null,
+        minBookingDays: 1,
+        date: "2026-10-25",
+        hoveredDate: "2026-10-26",
+        exactMinBookingDays: false,
+        isDateBlocked: () => false,
+    })).toBe(true);
+});

package/utils/is-date-inside-range.d.ts

@@ -1 +1,2 @@
-export declare function isDateInsideRange(date: Date, startDate: Date | null, endDate: Date | null): boolean;
+import { DateString } from "@uxf/core/date";
+export declare function isDateInsideRange(date: DateString, startDate: DateString | null, endDate: DateString | null): boolean;

package/utils/is-date-inside-range.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDateInsideRange = isDateInsideRange;
-const dayjs_utils_1 = require("./dayjs-utils");
 function isDateInsideRange(date, startDate, endDate) {
     if (startDate && endDate) {
-        return (0, dayjs_utils_1.dayjsEnRaw)(date).isBetween(startDate, endDate);
+        return startDate < date && date < endDate;
     }
     return false;
 }

package/utils/is-date-selected.test.js

@@ -2,12 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_date_inside_range_1 = require("./is-date-inside-range");
 test("isDateInsideRange", () => {
-    expect((0, is_date_inside_range_1.isDateInsideRange)(new Date("2021-08-08"), new Date("2021-06-08"), new Date("2021-08-12"))).toBe(true);
-    expect((0, is_date_inside_range_1.isDateInsideRange)(new Date("2021-08-08"), new Date("2021-08-07"), new Date("2021-08-12"))).toBe(true);
-    expect((0, is_date_inside_range_1.isDateInsideRange)(new Date("2021-08-08"), new Date("2021-06-08"), new Date("2021-08-09"))).toBe(true);
-    expect((0, is_date_inside_range_1.isDateInsideRange)(new Date("2021-08-08"), null, null)).toBe(false);
-    expect((0, is_date_inside_range_1.isDateInsideRange)(new Date("2021-08-08"), new Date("2021-06-08"), null)).toBe(false);
-    expect((0, is_date_inside_range_1.isDateInsideRange)(new Date("2021-08-08"), null, new Date("2021-08-09"))).toBe(false);
-    expect((0, is_date_inside_range_1.isDateInsideRange)(new Date("2021-08-08"), new Date("2021-06-08"), new Date("2021-08-01"))).toBe(false);
-    expect((0, is_date_inside_range_1.isDateInsideRange)(new Date("2021-08-08"), new Date("2021-08-10"), new Date("2021-08-25"))).toBe(false);
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-08-08", "2021-06-08", "2021-08-12")).toBe(true);
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-08-08", "2021-08-07", "2021-08-12")).toBe(true);
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-08-08", "2021-06-08", "2021-08-09")).toBe(true);
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-08-08", null, null)).toBe(false);
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-08-08", "2021-06-08", null)).toBe(false);
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-08-08", null, "2021-08-09")).toBe(false);
+    // endpoint not inside (exclusive)
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-06-08", "2021-06-08", "2021-08-01")).toBe(false);
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-08-01", "2021-06-08", "2021-08-01")).toBe(false);
+    // outside range
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-08-08", "2021-06-08", "2021-08-01")).toBe(false);
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2021-08-08", "2021-08-10", "2021-08-25")).toBe(false);
+});
+test("isDateInsideRange DST boundary (2026-10-25)", () => {
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2026-10-25", "2026-10-24", "2026-10-26")).toBe(true);
+    expect((0, is_date_inside_range_1.isDateInsideRange)("2026-10-24", "2026-10-24", "2026-10-26")).toBe(false); // exclusive
 });

package/utils/is-end-date.d.ts

@@ -1 +1,2 @@
-export declare function isEndDate(date: Date, endDate: Date | null): boolean;
+import { DateString } from "@uxf/core/date";
+export declare function isEndDate(date: DateString, endDate: DateString | null): boolean;

package/utils/is-end-date.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isEndDate = isEndDate;
-const dayjs_utils_1 = require("./dayjs-utils");
 function isEndDate(date, endDate) {
-    return Boolean(endDate && (0, dayjs_utils_1.dayjsEnRaw)(date).isSame(endDate, "day"));
+    return date === endDate;
 }

package/utils/is-end-date.test.js

@@ -2,10 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_end_date_1 = require("./is-end-date");
 test("isEndDate", () => {
-    expect((0, is_end_date_1.isEndDate)(new Date("2020-08-08"), new Date("2020-08-08"))).toBe(true);
-    expect((0, is_end_date_1.isEndDate)(new Date("2021-12-15"), new Date("2021-12-15"))).toBe(true);
-    expect((0, is_end_date_1.isEndDate)(new Date("1999-01-05"), new Date("1999-01-05"))).toBe(true);
-    expect((0, is_end_date_1.isEndDate)(new Date("2020-08-09"), new Date("2020-08-08"))).toBe(false);
-    expect((0, is_end_date_1.isEndDate)(new Date("2020-08-10"), new Date("2020-08-08"))).toBe(false);
-    expect((0, is_end_date_1.isEndDate)(new Date("2021-08-08"), new Date("2020-08-08"))).toBe(false);
+    expect((0, is_end_date_1.isEndDate)("2020-08-08", "2020-08-08")).toBe(true);
+    expect((0, is_end_date_1.isEndDate)("2021-12-15", "2021-12-15")).toBe(true);
+    expect((0, is_end_date_1.isEndDate)("1999-01-05", "1999-01-05")).toBe(true);
+    expect((0, is_end_date_1.isEndDate)("2020-08-09", "2020-08-08")).toBe(false);
+    expect((0, is_end_date_1.isEndDate)("2020-08-10", "2020-08-08")).toBe(false);
+    expect((0, is_end_date_1.isEndDate)("2021-08-08", "2020-08-08")).toBe(false);
+    expect((0, is_end_date_1.isEndDate)("2026-10-25", null)).toBe(false);
+});
+test("isEndDate DST fall-back (2026-10-25)", () => {
+    expect((0, is_end_date_1.isEndDate)("2026-10-25", "2026-10-25")).toBe(true);
+    expect((0, is_end_date_1.isEndDate)("2026-10-26", "2026-10-25")).toBe(false);
 });

package/utils/is-first-or-last-selected-date.d.ts

@@ -1 +1,2 @@
-export declare function isFirstOrLastSelectedDate(date: Date, startDate: Date | null, endDate: Date | null): boolean;
+import { DateString } from "@uxf/core/date";
+export declare function isFirstOrLastSelectedDate(date: DateString, startDate: DateString | null, endDate: DateString | null): boolean;

package/utils/is-first-or-last-selected-date.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isFirstOrLastSelectedDate = isFirstOrLastSelectedDate;
-const dayjs_utils_1 = require("./dayjs-utils");
 function isFirstOrLastSelectedDate(date, startDate, endDate) {
-    return Boolean((startDate && (0, dayjs_utils_1.dayjsEnRaw)(date).isSame(startDate, "day")) ||
-        (endDate && (0, dayjs_utils_1.dayjsEnRaw)(date).isSame(endDate, "day")));
+    return Boolean((startDate && date === startDate) || (endDate && date === endDate));
 }

package/utils/is-first-or-last-selected-date.test.js

@@ -2,10 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_first_or_last_selected_date_1 = require("./is-first-or-last-selected-date");
 test("isFirstOrLastSelectedDate", () => {
-    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)(new Date("2020-08-08"), new Date("2020-05-08"), new Date("2020-08-08"))).toBe(true);
-    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)(new Date("2021-12-15"), new Date("2021-12-01"), new Date("2021-12-15"))).toBe(true);
-    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)(new Date("1999-01-05"), new Date("1999-01-05"), new Date("1999-03-05"))).toBe(true);
-    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)(new Date("2020-08-09"), new Date("2020-08-08"), new Date("2020-08-10"))).toBe(false);
-    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)(new Date("2020-08-10"), new Date("2020-08-08"), new Date("2020-12-08"))).toBe(false);
-    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)(new Date("2021-08-08"), new Date("2020-08-08"), new Date("2020-01-08"))).toBe(false);
+    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2020-08-08", "2020-05-08", "2020-08-08")).toBe(true);
+    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2021-12-15", "2021-12-01", "2021-12-15")).toBe(true);
+    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("1999-01-05", "1999-01-05", "1999-03-05")).toBe(true);
+    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2020-08-09", "2020-08-08", "2020-08-10")).toBe(false);
+    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2020-08-10", "2020-08-08", "2020-12-08")).toBe(false);
+    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2021-08-08", "2020-08-08", "2020-01-08")).toBe(false);
+    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2026-10-25", "2026-10-25", null)).toBe(true);
+    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2026-10-25", null, "2026-10-25")).toBe(true);
+    expect((0, is_first_or_last_selected_date_1.isFirstOrLastSelectedDate)("2026-10-25", null, null)).toBe(false);
 });

package/utils/is-in-unavailable-dates.d.ts

@@ -1 +1,2 @@
-export declare function isInUnavailableDates(unavailableDates: Date[] | undefined, date: Date): boolean;
+import { DateString } from "@uxf/core/date";
+export declare function isInUnavailableDates(unavailableDates: DateString[] | undefined, date: DateString): boolean;

package/utils/is-in-unavailable-dates.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isInUnavailableDates = isInUnavailableDates;
-const dayjs_utils_1 = require("./dayjs-utils");
 function isInUnavailableDates(unavailableDates = [], date) {
-    return unavailableDates.some((_date) => (0, dayjs_utils_1.dayjsEnRaw)(date).isSame(_date, "day"));
+    return unavailableDates.some((d) => d === date);
 }