@pathscale/ui 1.1.37 → 1.1.39

package/dist/components/toast/index.d.ts

@@ -1 +1 @@
-export { default, type ToastProps } from "./Toast";
+export { default, ToastRoot, ToastProvider, ToastContent, ToastIndicator, ToastTitle, ToastDescription, ToastActionButton, ToastCloseButton, ToastQueue, toast, toastQueue, DEFAULT_GAP, DEFAULT_MAX_VISIBLE_TOAST, DEFAULT_SCALE_FACTOR, DEFAULT_TOAST_TIMEOUT, DEFAULT_TOAST_WIDTH, type ToastPlacement, type ToastVariant, type ToastActionProps, type ToastContentValue, type ToastQueueAddOptions, type ToastQueueItem, type ToastQueueOptions, type ToastRenderFn, type ToastRootProps, type ToastProviderProps, type ToastContentProps, type ToastIndicatorProps, type ToastTitleProps, type ToastDescriptionProps, type ToastActionButtonProps, type ToastCloseButtonProps, type HeroUIToastOptions, type ToastPromiseOptions, type ToastFunction, } from "./Toast";

package/dist/components/toast/index.js

@@ -1,3 +1,19 @@
 import * as __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__ from "./Toast.js";
+var __webpack_exports__DEFAULT_GAP = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.DEFAULT_GAP;
+var __webpack_exports__DEFAULT_MAX_VISIBLE_TOAST = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.DEFAULT_MAX_VISIBLE_TOAST;
+var __webpack_exports__DEFAULT_SCALE_FACTOR = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.DEFAULT_SCALE_FACTOR;
+var __webpack_exports__DEFAULT_TOAST_TIMEOUT = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.DEFAULT_TOAST_TIMEOUT;
+var __webpack_exports__DEFAULT_TOAST_WIDTH = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.DEFAULT_TOAST_WIDTH;
+var __webpack_exports__ToastActionButton = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.ToastActionButton;
+var __webpack_exports__ToastCloseButton = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.ToastCloseButton;
+var __webpack_exports__ToastContent = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.ToastContent;
+var __webpack_exports__ToastDescription = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.ToastDescription;
+var __webpack_exports__ToastIndicator = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.ToastIndicator;
+var __webpack_exports__ToastProvider = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.ToastProvider;
+var __webpack_exports__ToastQueue = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.ToastQueue;
+var __webpack_exports__ToastRoot = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.ToastRoot;
+var __webpack_exports__ToastTitle = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.ToastTitle;
 var __webpack_exports__default = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__["default"];
-export { __webpack_exports__default as default };
+var __webpack_exports__toast = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.toast;
+var __webpack_exports__toastQueue = __WEBPACK_EXTERNAL_MODULE__Toast_js_72ea0bce__.toastQueue;
+export { __webpack_exports__DEFAULT_GAP as DEFAULT_GAP, __webpack_exports__DEFAULT_MAX_VISIBLE_TOAST as DEFAULT_MAX_VISIBLE_TOAST, __webpack_exports__DEFAULT_SCALE_FACTOR as DEFAULT_SCALE_FACTOR, __webpack_exports__DEFAULT_TOAST_TIMEOUT as DEFAULT_TOAST_TIMEOUT, __webpack_exports__DEFAULT_TOAST_WIDTH as DEFAULT_TOAST_WIDTH, __webpack_exports__ToastActionButton as ToastActionButton, __webpack_exports__ToastCloseButton as ToastCloseButton, __webpack_exports__ToastContent as ToastContent, __webpack_exports__ToastDescription as ToastDescription, __webpack_exports__ToastIndicator as ToastIndicator, __webpack_exports__ToastProvider as ToastProvider, __webpack_exports__ToastQueue as ToastQueue, __webpack_exports__ToastRoot as ToastRoot, __webpack_exports__ToastTitle as ToastTitle, __webpack_exports__default as default, __webpack_exports__toast as toast, __webpack_exports__toastQueue as toastQueue };

package/dist/hooks/date/date.utils.d.ts

@@ -0,0 +1,30 @@
+export declare const DAYS_PER_WEEK = 7;
+export declare const CALENDAR_GRID_DAYS = 42;
+export type DateRangeValue = {
+    start: Date;
+    end: Date;
+};
+export declare const createCalendarDate: (year: number, monthIndex: number, day: number) => Date;
+export declare const normalizeDate: (value: Date | null | undefined) => Date | null;
+export declare const getToday: () => Date;
+export declare const parseDate: (value: string | null | undefined) => Date | null;
+export declare const formatDate: (value: Date | null | undefined, locale?: string, options?: Intl.DateTimeFormatOptions) => string;
+export declare const toISODate: (value: Date | null | undefined) => string;
+export declare const compareDates: (left: Date, right: Date) => number;
+export declare const compareMonths: (left: Date, right: Date) => number;
+export declare const isSameDay: (left: Date, right: Date) => boolean;
+export declare const isSameMonth: (left: Date, right: Date) => boolean;
+export declare const startOfMonth: (date: Date) => Date;
+export declare const addDays: (date: Date, amount: number) => Date;
+export declare const addMonths: (date: Date, amount: number) => Date;
+export declare const shiftDateByMonths: (date: Date, amount: number) => Date;
+export declare const buildCalendarGrid: (monthStart: Date, weekStartsOn?: number) => Date[];
+export declare const splitWeeks: <T>(items: T[], daysPerWeek?: number) => T[][];
+export declare const normalizeRange: (start: Date | null | undefined, end: Date | null | undefined) => {
+    start: Date | null;
+    end: Date | null;
+};
+export declare const createPreviewRange: (start: Date | null | undefined, end: Date | null | undefined, preview: Date | null | undefined) => {
+    start: Date | null;
+    end: Date | null;
+};

package/dist/hooks/date/date.utils.js

@@ -0,0 +1,112 @@
+const DAYS_PER_WEEK = 7;
+const CALENDAR_GRID_DAYS = 42;
+const ISO_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const createCalendarDate = (year, monthIndex, day)=>new Date(year, monthIndex, day, 12, 0, 0, 0);
+const normalizeDate = (value)=>{
+    if (!(value instanceof Date)) return null;
+    if (Number.isNaN(value.getTime())) return null;
+    return createCalendarDate(value.getFullYear(), value.getMonth(), value.getDate());
+};
+const getToday = ()=>{
+    const now = new Date();
+    return createCalendarDate(now.getFullYear(), now.getMonth(), now.getDate());
+};
+const parseDate = (value)=>{
+    if (!value) return null;
+    const match = ISO_DATE_PATTERN.exec(value);
+    if (!match) return null;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return null;
+    const parsed = createCalendarDate(year, month - 1, day);
+    if (parsed.getFullYear() !== year || parsed.getMonth() !== month - 1 || parsed.getDate() !== day) return null;
+    return parsed;
+};
+const formatDate = (value, locale = "en-US", options = {
+    day: "numeric",
+    month: "short",
+    year: "numeric"
+})=>{
+    const date = normalizeDate(value);
+    if (!date) return "";
+    return new Intl.DateTimeFormat(locale, options).format(date);
+};
+const pad = (value)=>String(value).padStart(2, "0");
+const toISODate = (value)=>{
+    const date = normalizeDate(value);
+    if (!date) return "";
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+};
+const toDateKey = (date)=>10000 * date.getFullYear() + (date.getMonth() + 1) * 100 + date.getDate();
+const compareDates = (left, right)=>toDateKey(left) - toDateKey(right);
+const compareMonths = (left, right)=>(left.getFullYear() - right.getFullYear()) * 12 + (left.getMonth() - right.getMonth());
+const isSameDay = (left, right)=>0 === compareDates(left, right);
+const isSameMonth = (left, right)=>left.getFullYear() === right.getFullYear() && left.getMonth() === right.getMonth();
+const startOfMonth = (date)=>createCalendarDate(date.getFullYear(), date.getMonth(), 1);
+const addDays = (date, amount)=>createCalendarDate(date.getFullYear(), date.getMonth(), date.getDate() + amount);
+const addMonths = (date, amount)=>createCalendarDate(date.getFullYear(), date.getMonth() + amount, 1);
+const shiftDateByMonths = (date, amount)=>{
+    const base = createCalendarDate(date.getFullYear(), date.getMonth() + amount, 1);
+    const maxDay = new Date(base.getFullYear(), base.getMonth() + 1, 0).getDate();
+    return createCalendarDate(base.getFullYear(), base.getMonth(), Math.min(date.getDate(), maxDay));
+};
+const buildCalendarGrid = (monthStart, weekStartsOn = 0)=>{
+    const monthFirstDay = startOfMonth(monthStart);
+    const offset = (monthFirstDay.getDay() - weekStartsOn + DAYS_PER_WEEK) % DAYS_PER_WEEK;
+    const gridStart = addDays(monthFirstDay, -offset);
+    return Array.from({
+        length: CALENDAR_GRID_DAYS
+    }, (_, index)=>addDays(gridStart, index));
+};
+const splitWeeks = (items, daysPerWeek = DAYS_PER_WEEK)=>{
+    const weeks = [];
+    for(let index = 0; index < items.length; index += daysPerWeek)weeks.push(items.slice(index, index + daysPerWeek));
+    return weeks;
+};
+const normalizeRange = (start, end)=>{
+    const normalizedStart = normalizeDate(start);
+    const normalizedEnd = normalizeDate(end);
+    if (!normalizedStart && !normalizedEnd) return {
+        start: null,
+        end: null
+    };
+    if (normalizedStart && !normalizedEnd) return {
+        start: normalizedStart,
+        end: null
+    };
+    if (!normalizedStart && normalizedEnd) return {
+        start: normalizedEnd,
+        end: null
+    };
+    if (!normalizedStart || !normalizedEnd) return {
+        start: null,
+        end: null
+    };
+    if (compareDates(normalizedStart, normalizedEnd) <= 0) return {
+        start: normalizedStart,
+        end: normalizedEnd
+    };
+    return {
+        start: normalizedEnd,
+        end: normalizedStart
+    };
+};
+const createPreviewRange = (start, end, preview)=>{
+    const normalizedStart = normalizeDate(start);
+    const normalizedEnd = normalizeDate(end);
+    const normalizedPreview = normalizeDate(preview);
+    if (!normalizedStart || normalizedEnd || !normalizedPreview) return {
+        start: null,
+        end: null
+    };
+    if (compareDates(normalizedPreview, normalizedStart) < 0) return {
+        start: normalizedPreview,
+        end: normalizedStart
+    };
+    return {
+        start: normalizedStart,
+        end: normalizedPreview
+    };
+};
+export { CALENDAR_GRID_DAYS, DAYS_PER_WEEK, addDays, addMonths, buildCalendarGrid, compareDates, compareMonths, createCalendarDate, createPreviewRange, formatDate, getToday, isSameDay, isSameMonth, normalizeDate, normalizeRange, parseDate, shiftDateByMonths, splitWeeks, startOfMonth, toISODate };

package/dist/hooks/date/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./date.utils";
+export * from "./useDateSelection";
+export * from "./useRangeSelection";
+export * from "./useCalendarNavigation";
+export * from "./useCalendarState";
+export * from "./usePickerOpenState";

package/dist/hooks/date/index.js

@@ -0,0 +1,6 @@
+export * from "./date.utils.js";
+export * from "./useDateSelection.js";
+export * from "./useRangeSelection.js";
+export * from "./useCalendarNavigation.js";
+export * from "./useCalendarState.js";
+export * from "./usePickerOpenState.js";

package/dist/hooks/date/useCalendarNavigation.d.ts

@@ -0,0 +1,21 @@
+import { type Accessor } from "solid-js";
+type CalendarNavigationOptions = {
+    initialFocusedDate: Accessor<Date>;
+    minDate: Accessor<Date | null>;
+    maxDate: Accessor<Date | null>;
+    isDateDisabled: (date: Date) => boolean;
+};
+export declare const useCalendarNavigation: (options: CalendarNavigationOptions) => {
+    visibleMonth: Accessor<Date>;
+    focusedDate: Accessor<Date>;
+    setFocusedDate: import("solid-js").Setter<Date>;
+    clampVisibleMonth: (nextVisibleMonth: Date) => Date;
+    setVisibleMonthFromDate: (date: Date) => void;
+    findNearestEnabledDate: (startDate: Date, direction: 1 | -1) => Date;
+    moveFocusToDate: (date: Date, direction: 1 | -1) => Date;
+    navigateMonth: (direction: -1 | 1) => Date | null;
+    canNavigatePrevious: Accessor<boolean>;
+    canNavigateNext: Accessor<boolean>;
+    syncFocusedDate: (value: Date | null) => void;
+};
+export {};

package/dist/hooks/date/useCalendarNavigation.js

@@ -0,0 +1,70 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+import * as __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__ from "./date.utils.js";
+const useCalendarNavigation = (options)=>{
+    const [visibleMonth, setVisibleMonth] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)((0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.startOfMonth)(options.initialFocusedDate()));
+    const [focusedDate, setFocusedDate] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)(options.initialFocusedDate());
+    const clampVisibleMonth = (nextVisibleMonth)=>{
+        const min = options.minDate();
+        const max = options.maxDate();
+        if (min && (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.compareMonths)(nextVisibleMonth, (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.startOfMonth)(min)) < 0) return (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.startOfMonth)(min);
+        if (max && (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.compareMonths)(nextVisibleMonth, (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.startOfMonth)(max)) > 0) return (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.startOfMonth)(max);
+        return nextVisibleMonth;
+    };
+    const setVisibleMonthFromDate = (date)=>{
+        const nextMonth = (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.startOfMonth)(date);
+        if (!(0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.isSameMonth)(nextMonth, visibleMonth())) setVisibleMonth(clampVisibleMonth(nextMonth));
+    };
+    const findNearestEnabledDate = (startDate, direction)=>{
+        let current = startDate;
+        for(let index = 0; index < 400; index += 1){
+            if (!options.isDateDisabled(current)) return current;
+            current = (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.addDays)(current, direction);
+        }
+        return startDate;
+    };
+    const moveFocusToDate = (date, direction)=>{
+        const nextFocus = options.isDateDisabled(date) ? findNearestEnabledDate(date, direction) : date;
+        setFocusedDate(nextFocus);
+        setVisibleMonthFromDate(nextFocus);
+        return nextFocus;
+    };
+    const navigateMonth = (direction)=>{
+        const nextMonth = clampVisibleMonth((0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.addMonths)(visibleMonth(), direction));
+        if ((0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.isSameMonth)(nextMonth, visibleMonth())) return null;
+        setVisibleMonth(nextMonth);
+        const nextFocus = findNearestEnabledDate((0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.shiftDateByMonths)(focusedDate(), direction), direction);
+        setFocusedDate(nextFocus);
+        return nextFocus;
+    };
+    const canNavigatePrevious = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>{
+        const previousMonth = (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.addMonths)(visibleMonth(), -1);
+        const min = options.minDate();
+        if (!min) return true;
+        return (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.compareMonths)(previousMonth, (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.startOfMonth)(min)) >= 0;
+    });
+    const canNavigateNext = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>{
+        const nextMonth = (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.addMonths)(visibleMonth(), 1);
+        const max = options.maxDate();
+        if (!max) return true;
+        return (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.compareMonths)(nextMonth, (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.startOfMonth)(max)) <= 0;
+    });
+    const syncFocusedDate = (value)=>{
+        if (!value) return;
+        setFocusedDate(value);
+        setVisibleMonthFromDate(value);
+    };
+    return {
+        visibleMonth,
+        focusedDate,
+        setFocusedDate,
+        clampVisibleMonth,
+        setVisibleMonthFromDate,
+        findNearestEnabledDate,
+        moveFocusToDate,
+        navigateMonth,
+        canNavigatePrevious,
+        canNavigateNext,
+        syncFocusedDate
+    };
+};
+export { useCalendarNavigation };

package/dist/hooks/date/useCalendarState.d.ts

@@ -0,0 +1,45 @@
+import { type Accessor } from "solid-js";
+export type CalendarSelectionMode = "single" | "range";
+type CalendarStateOptions = {
+    selectionMode: Accessor<CalendarSelectionMode>;
+    locale: Accessor<string>;
+    weekdayFormat: Accessor<"narrow" | "short" | "long">;
+    visibleMonth: Accessor<Date>;
+    focusedDate: Accessor<Date>;
+    selectedDate: Accessor<Date | null>;
+    rangeStart: Accessor<Date | null>;
+    rangeEnd: Accessor<Date | null>;
+    rangePreview: Accessor<Date | null>;
+    isDateDisabled: (date: Date) => boolean;
+    isDateUnavailable: (date: Date) => boolean;
+};
+export type CalendarCellState = {
+    isOutsideMonth: boolean;
+    isSelected: boolean;
+    isRangeStart: boolean;
+    isRangeEnd: boolean;
+    isInCommittedRange: boolean;
+    isInPreviewRange: boolean;
+    isInRange: boolean;
+    isToday: boolean;
+    isUnavailable: boolean;
+    isDisabled: boolean;
+    isFocused: boolean;
+    isAriaSelected: boolean;
+};
+export declare const useCalendarState: (options: CalendarStateOptions) => {
+    monthFormatter: Accessor<Intl.DateTimeFormat>;
+    dayLabelFormatter: Accessor<Intl.DateTimeFormat>;
+    weekdayLabels: Accessor<string[]>;
+    calendarWeeks: Accessor<Date[][]>;
+    normalizedRange: Accessor<{
+        start: Date | null;
+        end: Date | null;
+    }>;
+    previewRange: Accessor<{
+        start: Date | null;
+        end: Date | null;
+    }>;
+    getCellState: (date: Date) => CalendarCellState;
+};
+export {};

package/dist/hooks/date/useCalendarState.js

@@ -0,0 +1,66 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+import * as __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__ from "./date.utils.js";
+const useCalendarState = (options)=>{
+    const monthFormatter = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>new Intl.DateTimeFormat(options.locale(), {
+            month: "long",
+            year: "numeric"
+        }));
+    const dayLabelFormatter = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>new Intl.DateTimeFormat(options.locale(), {
+            dateStyle: "full"
+        }));
+    const weekdayFormatter = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>new Intl.DateTimeFormat(options.locale(), {
+            weekday: options.weekdayFormat()
+        }));
+    const weekdayLabels = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>{
+        const firstSunday = new Date(2024, 0, 7, 12, 0, 0, 0);
+        return Array.from({
+            length: 7
+        }, (_, index)=>weekdayFormatter().format((0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.addDays)(firstSunday, index)));
+    });
+    const calendarWeeks = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>(0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.splitWeeks)((0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.buildCalendarGrid)(options.visibleMonth(), 0)));
+    const normalizedRange = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>(0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.normalizeRange)(options.rangeStart(), options.rangeEnd()));
+    const previewRange = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>(0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.createPreviewRange)(normalizedRange().start, normalizedRange().end, options.rangePreview()));
+    const todayDate = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>(0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.getToday)());
+    const getCellState = (date)=>{
+        const mode = options.selectionMode();
+        const selectedDate = options.selectedDate();
+        const normalized = normalizedRange();
+        const preview = previewRange();
+        const isOutsideMonth = !(0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.isSameMonth)(date, options.visibleMonth());
+        const isSelected = "single" === mode && null !== selectedDate && (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.isSameDay)(date, selectedDate);
+        const isRangeStart = "range" === mode && null !== normalized.start && (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.isSameDay)(date, normalized.start);
+        const isRangeEnd = "range" === mode && null !== normalized.end && (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.isSameDay)(date, normalized.end);
+        const isInCommittedRange = "range" === mode && null !== normalized.start && null !== normalized.end && (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.compareDates)(date, normalized.start) >= 0 && (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.compareDates)(date, normalized.end) <= 0;
+        const isInPreviewRange = "range" === mode && null !== preview.start && null !== preview.end && (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.compareDates)(date, preview.start) >= 0 && (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.compareDates)(date, preview.end) <= 0;
+        const isInRange = isInCommittedRange || isInPreviewRange;
+        const isToday = (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.isSameDay)(date, todayDate());
+        const isUnavailable = options.isDateUnavailable(date);
+        const isDisabled = options.isDateDisabled(date);
+        const isFocused = (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.isSameDay)(date, options.focusedDate());
+        const isAriaSelected = "range" === mode ? isRangeStart || isRangeEnd || isInRange : isSelected;
+        return {
+            isOutsideMonth,
+            isSelected,
+            isRangeStart,
+            isRangeEnd,
+            isInCommittedRange,
+            isInPreviewRange,
+            isInRange,
+            isToday,
+            isUnavailable,
+            isDisabled,
+            isFocused,
+            isAriaSelected
+        };
+    };
+    return {
+        monthFormatter,
+        dayLabelFormatter,
+        weekdayLabels,
+        calendarWeeks,
+        normalizedRange,
+        previewRange,
+        getCellState
+    };
+};
+export { useCalendarState };

package/dist/hooks/date/useDateSelection.d.ts

@@ -0,0 +1,12 @@
+import { type Accessor } from "solid-js";
+type DateSelectionOptions = {
+    value: Accessor<Date | undefined>;
+    defaultValue: Accessor<Date | undefined>;
+    onChange: Accessor<((value: Date) => void) | undefined>;
+};
+export declare const useDateSelection: (options: DateSelectionOptions) => {
+    isControlled: Accessor<boolean>;
+    selectedDate: Accessor<Date | null>;
+    setSelectedDate: (value: Date) => void;
+};
+export {};

package/dist/hooks/date/useDateSelection.js

@@ -0,0 +1,22 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+import * as __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__ from "./date.utils.js";
+const useDateSelection = (options)=>{
+    const [internalValue, setInternalValue] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)((0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.normalizeDate)(options.defaultValue()));
+    const isControlled = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>void 0 !== options.value());
+    const selectedDate = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>{
+        if (isControlled()) return (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.normalizeDate)(options.value());
+        return internalValue();
+    });
+    const setSelectedDate = (value)=>{
+        const normalized = (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.normalizeDate)(value);
+        if (!normalized) return;
+        if (!isControlled()) setInternalValue(normalized);
+        options.onChange()?.(normalized);
+    };
+    return {
+        isControlled,
+        selectedDate,
+        setSelectedDate
+    };
+};
+export { useDateSelection };

package/dist/hooks/date/usePickerOpenState.d.ts

@@ -0,0 +1,15 @@
+import { type Accessor } from "solid-js";
+type PickerOpenStateOptions = {
+    isOpen: Accessor<boolean | undefined>;
+    defaultOpen: Accessor<boolean | undefined>;
+    onOpenChange: Accessor<((value: boolean) => void) | undefined>;
+    isDisabled: Accessor<boolean>;
+};
+export declare const usePickerOpenState: (options: PickerOpenStateOptions) => {
+    isOpen: Accessor<boolean>;
+    isControlled: Accessor<boolean>;
+    setOpen: (nextOpen: boolean) => void;
+    toggleOpen: () => void;
+    setRootRef: import("solid-js").Setter<HTMLElement | undefined>;
+};
+export {};

package/dist/hooks/date/usePickerOpenState.js

@@ -0,0 +1,50 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+const usePickerOpenState = (options)=>{
+    const [internalOpen, setInternalOpen] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)(Boolean(options.defaultOpen()));
+    const [rootRef, setRootRef] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)(void 0);
+    const isControlled = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>void 0 !== options.isOpen());
+    const isOpen = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>isControlled() ? Boolean(options.isOpen()) : internalOpen());
+    const setOpen = (nextOpen)=>{
+        if (nextOpen && options.isDisabled()) return;
+        const previous = isOpen();
+        if (!isControlled()) setInternalOpen(nextOpen);
+        if (previous !== nextOpen) options.onOpenChange()?.(nextOpen);
+    };
+    const toggleOpen = ()=>{
+        setOpen(!isOpen());
+    };
+    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.onMount)(()=>{
+        const handlePointerDown = (event)=>{
+            if (!isOpen()) return;
+            const root = rootRef();
+            if (!root) return;
+            if (root.contains(event.target)) return;
+            setOpen(false);
+        };
+        const handleGlobalKeyDown = (event)=>{
+            if (!isOpen()) return;
+            if ("Escape" !== event.key) return;
+            event.preventDefault();
+            setOpen(false);
+        };
+        document.addEventListener("pointerdown", handlePointerDown);
+        document.addEventListener("keydown", handleGlobalKeyDown);
+        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.onCleanup)(()=>{
+            document.removeEventListener("pointerdown", handlePointerDown);
+            document.removeEventListener("keydown", handleGlobalKeyDown);
+        });
+    });
+    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createEffect)(()=>{
+        if (!options.isDisabled()) return;
+        if (!isOpen()) return;
+        setOpen(false);
+    });
+    return {
+        isOpen,
+        isControlled,
+        setOpen,
+        toggleOpen,
+        setRootRef
+    };
+};
+export { usePickerOpenState };

package/dist/hooks/date/useRangeSelection.d.ts

@@ -0,0 +1,26 @@
+import { type Accessor } from "solid-js";
+import { type DateRangeValue } from "./date.utils";
+export type ControlledDateRangeValue = DateRangeValue | null;
+type RangeSelectionOptions = {
+    value: Accessor<ControlledDateRangeValue | undefined>;
+    defaultValue: Accessor<ControlledDateRangeValue | undefined>;
+    onChange: Accessor<((value: ControlledDateRangeValue) => void) | undefined>;
+};
+export declare const useRangeSelection: (options: RangeSelectionOptions) => {
+    isControlled: Accessor<boolean>;
+    isSelectingEnd: Accessor<boolean>;
+    committedRange: Accessor<ControlledDateRangeValue>;
+    hoveredDate: Accessor<Date | null>;
+    rangeStart: Accessor<Date | null>;
+    rangeEnd: Accessor<Date | null>;
+    previewRange: Accessor<{
+        start: Date | null;
+        end: Date | null;
+    }>;
+    focusDate: Accessor<Date | null>;
+    selectDate: (value: Date) => void;
+    setCommittedRange: (nextValue: ControlledDateRangeValue) => void;
+    setHoverDate: (value: Date | undefined) => void;
+    clearPendingSelection: () => void;
+};
+export {};

package/dist/hooks/date/useRangeSelection.js

@@ -0,0 +1,74 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+import * as __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__ from "./date.utils.js";
+const normalizeCompleteRange = (value)=>{
+    if (!value) return null;
+    const normalized = (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.normalizeRange)(value.start, value.end);
+    if (!normalized.start || !normalized.end) return null;
+    return {
+        start: normalized.start,
+        end: normalized.end
+    };
+};
+const useRangeSelection = (options)=>{
+    const [internalCommittedRange, setInternalCommittedRange] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)(normalizeCompleteRange(options.defaultValue()));
+    const [pendingStartDate, setPendingStartDate] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)(null);
+    const [hoveredDate, setHoveredDate] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)(null);
+    const isControlled = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>void 0 !== options.value());
+    const committedRange = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>{
+        if (isControlled()) return normalizeCompleteRange(options.value());
+        return internalCommittedRange();
+    });
+    const isSelectingEnd = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>null !== pendingStartDate());
+    const rangeStart = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>pendingStartDate() ?? committedRange()?.start ?? null);
+    const rangeEnd = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>pendingStartDate() ? null : committedRange()?.end ?? null);
+    const previewRange = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>(0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.createPreviewRange)(rangeStart(), rangeEnd(), hoveredDate()));
+    const focusDate = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>rangeEnd() ?? rangeStart() ?? null);
+    const setCommittedRange = (nextValue)=>{
+        const normalized = normalizeCompleteRange(nextValue);
+        if (!isControlled()) setInternalCommittedRange(normalized);
+        options.onChange()?.(normalized);
+    };
+    const clearPendingSelection = ()=>{
+        setPendingStartDate(null);
+        setHoveredDate(null);
+    };
+    const setHoverDate = (value)=>{
+        if (!isSelectingEnd()) return void setHoveredDate(null);
+        setHoveredDate((0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.normalizeDate)(value));
+    };
+    const selectDate = (value)=>{
+        const normalized = (0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.normalizeDate)(value);
+        if (!normalized) return;
+        const pendingStart = pendingStartDate();
+        if (!pendingStart) {
+            setPendingStartDate(normalized);
+            setHoveredDate(null);
+            return;
+        }
+        if ((0, __WEBPACK_EXTERNAL_MODULE__date_utils_js_7a3c9532__.compareDates)(normalized, pendingStart) < 0) {
+            setPendingStartDate(normalized);
+            setHoveredDate(null);
+            return;
+        }
+        setCommittedRange({
+            start: pendingStart,
+            end: normalized
+        });
+        clearPendingSelection();
+    };
+    return {
+        isControlled,
+        isSelectingEnd,
+        committedRange,
+        hoveredDate,
+        rangeStart,
+        rangeEnd,
+        previewRange,
+        focusDate,
+        selectDate,
+        setCommittedRange,
+        setHoverDate,
+        clearPendingSelection
+    };
+};
+export { useRangeSelection };

package/dist/hooks/form/useForm.d.ts

@@ -1,11 +1,11 @@
+import { type GenericSchema } from "valibot";
 import type { ObjectSetter, Paths } from "@felte/common";
 import type { Accessor } from "solid-js";
-import type { z } from "zod";
 type AnyValues = Record<string, unknown>;
 export type FormPathQuery<TValues extends AnyValues = AnyValues> = string | ((data: TValues) => unknown);
 export type FormDirective = (element: HTMLFormElement, accessor?: Accessor<unknown>) => void | (() => void);
 export type UseFormOptions<TValues extends AnyValues = AnyValues> = {
-    schema?: z.ZodType<TValues>;
+    schema?: GenericSchema;
     initialValues?: TValues;
     onSubmit?: (values: TValues) => void | Promise<void>;
 };

package/dist/hooks/form/useForm.js

@@ -1,5 +1,5 @@
 import * as __WEBPACK_EXTERNAL_MODULE__felte_solid_6a709b1d__ from "@felte/solid";
-import * as __WEBPACK_EXTERNAL_MODULE__felte_validator_zod_bb07151a__ from "@felte/validator-zod";
+import * as __WEBPACK_EXTERNAL_MODULE_valibot__ from "valibot";
 const FORM_CONTROLLER_REGISTRY = new WeakMap();
 const getClosestFormElement = (element)=>{
     if (!element) return;
@@ -19,11 +19,16 @@ const useForm = (options = {})=>{
             await options.onSubmit?.(values);
         }
     };
-    if (options.schema) formConfig.extend = [
-        (0, __WEBPACK_EXTERNAL_MODULE__felte_validator_zod_bb07151a__.validator)({
-            schema: options.schema
-        })
-    ];
+    if (options.schema) formConfig.validate = (values)=>{
+        const result = (0, __WEBPACK_EXTERNAL_MODULE_valibot__.safeParse)(options.schema, values);
+        if (result.success) return;
+        const errors = {};
+        for (const issue of result.issues)if (issue.path) {
+            const path = issue.path.map((p)=>p.key).join(".");
+            if (!errors[path]) errors[path] = issue.message;
+        }
+        return errors;
+    };
     const { form: felteForm, errors, touched, data, isValid, isSubmitting, setData, setErrors, setWarnings, setTouched, reset } = (0, __WEBPACK_EXTERNAL_MODULE__felte_solid_6a709b1d__.createForm)(formConfig);
     let controller;
     const directive = (element, accessor)=>{