@uxf/datepicker 11.111.0-canary.1 → 11.111.2

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

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

package/utils/get-weekday-labels.js

@@ -1,12 +1,10 @@
 "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 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)));
+    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));
 }

package/utils/get-years.js

@@ -1,12 +1,11 @@
 "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)((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) };
-    });
+    return (0, get_each_1.getEach)(startYear, endYear, "year").map((d) => ({
+        date: d,
+        yearLabel: yearLabelFormat(d),
+    }));
 }

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

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

package/utils/is-date-blocked.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDateBlocked = isDateBlocked;
-const date_string_1 = require("./date-string");
+const dayjs_utils_1 = require("./dayjs-utils");
 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) ||
-        (minBookingDate && date < minBookingDate) ||
-        (maxBookingDate && date > maxBookingDate) ||
+        (compareMinDate && date < compareMinDate) ||
+        (compareMaxDate && date > compareMaxDate) ||
         (startDate &&
             !endDate &&
             minBookingDays > 1 &&
-            date > startDate &&
-            date < (0, date_string_1.addDays)(startDate, minBookingDays - 1)) ||
-        (isDateBlockedFn && isDateBlockedFn((0, date_string_1.fromDateString)(date))));
+            (0, dayjs_utils_1.dayjsEnWithTz)(date).isBetween(startDate, (0, dayjs_utils_1.dayjsEnWithTz)(startDate).add(minBookingDays - 1, "day"))) ||
+        (isDateBlockedFn && isDateBlockedFn(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: "2021-08-08",
+        startDate: new Date("2021-08-08"),
         endDate: null,
         minBookingDays: 1,
         minBookingDate: undefined,
         maxBookingDate: undefined,
-        date: "2021-08-08",
+        date: new Date("2021-08-08"),
         unavailableDates: undefined,
         isDateBlockedFn: () => true,
     })).toBe(true);
-    // not blocked
+    // start day only
     expect((0, is_date_blocked_1.isDateBlocked)({
-        startDate: "2021-08-08",
+        startDate: new Date("2021-08-08"),
         endDate: null,
         minBookingDays: 1,
         minBookingDate: undefined,
         maxBookingDate: undefined,
-        date: "2021-08-08",
+        date: new Date("2021-08-08"),
         unavailableDates: undefined,
         isDateBlockedFn: undefined,
     })).toBe(false);
@@ -29,9 +29,9 @@ test("isDateBlocked", () => {
         startDate: null,
         endDate: null,
         minBookingDays: 1,
-        minBookingDate: "2021-08-10",
+        minBookingDate: new Date("2021-08-10"),
         maxBookingDate: undefined,
-        date: "2021-08-08",
+        date: new Date("2021-08-08"),
         unavailableDates: undefined,
         isDateBlockedFn: undefined,
     })).toBe(true);
@@ -41,8 +41,8 @@ test("isDateBlocked", () => {
         endDate: null,
         minBookingDays: 1,
         minBookingDate: undefined,
-        maxBookingDate: "2021-08-06",
-        date: "2021-08-08",
+        maxBookingDate: new Date("2021-08-06"),
+        date: new Date("2021-08-08"),
         unavailableDates: undefined,
         isDateBlockedFn: undefined,
     })).toBe(true);
@@ -53,105 +53,8 @@ test("isDateBlocked", () => {
         minBookingDays: 1,
         minBookingDate: undefined,
         maxBookingDate: undefined,
-        date: "2021-08-08",
-        unavailableDates: ["2021-08-08"],
+        date: new Date("2021-08-08"),
+        unavailableDates: [new Date("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,10 +1,9 @@
-import { DateString } from "@uxf/core/date";
 export interface IsDateHoveredProps {
-    startDate: DateString | null;
-    endDate: DateString | null;
-    date: DateString;
-    isDateBlocked: ((date: DateString) => boolean) | null;
-    hoveredDate: DateString | null;
+    startDate: Date | null;
+    endDate: Date | null;
+    date: Date;
+    isDateBlocked: ((date: Date) => boolean) | null;
+    hoveredDate: Date | null;
     minBookingDays: number;
     exactMinBookingDays: boolean;
 }

package/utils/is-date-hovered.js

@@ -1,41 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDateHovered = isDateHovered;
-const date_string_1 = require("./date-string");
+const dayjs_utils_1 = require("./dayjs-utils");
 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 &&
-        date > hoveredDate &&
-        date < (0, date_string_1.addDays)(hoveredDate, minBookingDays - 1)) {
-        return isRangeUnblocked(hoveredDate, (0, date_string_1.addDays)(hoveredDate, minBookingDays - 1), isDateBlocked);
+        (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));
     }
     else if (
-    // min booking days (start date hovered)
+    // min booking days
     startDate &&
         !endDate &&
         hoveredDate &&
-        date > startDate &&
-        date < (0, date_string_1.addDays)(startDate, minBookingDays - 1) &&
-        startDate === 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") &&
         minBookingDays > 1) {
-        return isRangeUnblocked(startDate, (0, date_string_1.addDays)(startDate, minBookingDays - 1), isDateBlocked);
+        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));
     }
     else if (
-    // normal hover range
+    // normal
     startDate &&
         !endDate &&
         hoveredDate &&
-        hoveredDate >= startDate &&
-        date > startDate &&
-        date < hoveredDate) {
-        return isRangeUnblocked(startDate, hoveredDate, isDateBlocked);
+        !(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));
     }
     return false;
 }

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

@@ -1,89 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_date_hovered_1 = require("./is-date-hovered");
-test("isDateHovered — exact min booking days", () => {
-    // date within exact range but blocked
+test("isDateHovered", () => {
+    // exact min booking days
     expect((0, is_date_hovered_1.isDateHovered)({
         startDate: null,
         endDate: null,
         minBookingDays: 5,
-        date: "2021-08-08",
-        hoveredDate: "2021-08-07",
+        date: new Date("2021-08-08"),
+        hoveredDate: new Date("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: "2021-08-08",
-        hoveredDate: "2021-08-07",
+        date: new Date("2021-08-08"),
+        hoveredDate: new Date("2021-08-07"),
         exactMinBookingDays: true,
         isDateBlocked: () => false,
     })).toBe(true);
-});
-test("isDateHovered — min booking days", () => {
+    // min booking days
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: "2021-08-07",
+        startDate: new Date("2021-08-07"),
         endDate: null,
         minBookingDays: 5,
-        date: "2021-08-08",
-        hoveredDate: "2021-08-07",
+        date: new Date("2021-08-08"),
+        hoveredDate: new Date("2021-08-07"),
         exactMinBookingDays: false,
         isDateBlocked: () => true,
     })).toBe(false);
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: "2021-08-07",
+        startDate: new Date("2021-08-07"),
         endDate: null,
         minBookingDays: 5,
-        date: "2021-08-08",
-        hoveredDate: "2021-08-07",
+        date: new Date("2021-08-08"),
+        hoveredDate: new Date("2021-08-07"),
         exactMinBookingDays: false,
         isDateBlocked: () => false,
     })).toBe(true);
-});
-test("isDateHovered — normal hover range", () => {
-    // blocked
+    // normal
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: "2021-08-07",
+        startDate: new Date("2021-08-07"),
         endDate: null,
         minBookingDays: 1,
-        date: "2021-08-08",
-        hoveredDate: "2021-08-09",
+        date: new Date("2021-08-08"),
+        hoveredDate: new Date("2021-08-09"),
         exactMinBookingDays: false,
         isDateBlocked: () => true,
     })).toBe(false);
-    // not blocked
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: "2021-08-07",
+        startDate: new Date("2021-08-07"),
         endDate: null,
         minBookingDays: 1,
-        date: "2021-08-08",
-        hoveredDate: "2021-08-09",
+        date: new Date("2021-08-08"),
+        hoveredDate: new Date("2021-08-09"),
         exactMinBookingDays: false,
         isDateBlocked: () => false,
     })).toBe(true);
-});
-test("isDateHovered — with endDate returns false", () => {
+    // with endDate
     expect((0, is_date_hovered_1.isDateHovered)({
-        startDate: "2021-08-07",
-        endDate: "2021-08-12",
+        startDate: new Date("2021-08-07"),
+        endDate: new Date("2021-08-12"),
         minBookingDays: 1,
-        date: "2021-08-08",
-        hoveredDate: "2021-08-07",
+        date: new Date("2021-08-08"),
+        hoveredDate: new Date("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,2 +1 @@
-import { DateString } from "@uxf/core/date";
-export declare function isDateInsideRange(date: DateString, startDate: DateString | null, endDate: DateString | null): boolean;
+export declare function isDateInsideRange(date: Date, startDate: Date | null, endDate: Date | null): boolean;

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

@@ -1,9 +1,10 @@
 "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 startDate < date && date < endDate;
+        return (0, dayjs_utils_1.dayjsEnRaw)(date).isBetween(startDate, endDate);
     }
     return false;
 }

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

@@ -2,20 +2,12 @@
 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)("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
+    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);
 });

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

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

package/utils/is-end-date.js

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

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

@@ -2,15 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_end_date_1 = require("./is-end-date");
 test("isEndDate", () => {
-    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);
+    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);
 });

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

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

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

@@ -1,6 +1,8 @@
 "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 && date === startDate) || (endDate && date === endDate));
+    return Boolean((startDate && (0, dayjs_utils_1.dayjsEnRaw)(date).isSame(startDate, "day")) ||
+        (endDate && (0, dayjs_utils_1.dayjsEnRaw)(date).isSame(endDate, "day")));
 }

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

@@ -2,13 +2,10 @@
 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)("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);
+    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);
 });

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

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

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

@@ -1,6 +1,7 @@
 "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((d) => d === date);
+    return unavailableDates.some((_date) => (0, dayjs_utils_1.dayjsEnRaw)(date).isSame(_date, "day"));
 }