@pathscale/ui 1.1.56 → 1.1.58

package/dist/components/video-preview/VideoPreview.js

@@ -1,6 +1,7 @@
 import * as __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__ from "solid-js/web";
 import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
 import * as __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__ from "tailwind-merge";
+import * as __WEBPACK_EXTERNAL_MODULE__VideoPreview_classes_js_991e0adc__ from "./VideoPreview.classes.js";
 var _tmpl$ = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.template)("<video>");
 const VideoPreview = (props)=>{
     const [local, others] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.splitProps)(props, [
@@ -38,10 +39,10 @@ const VideoPreview = (props)=>{
                     },
                     get ["data-theme"] () {
                         return local.dataTheme;
-                    },
-                    get ["class"] () {
-                        return (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)(mirror() && "-scale-x-100", local.class, local.className);
-                    },
+                    }
+                }, ()=>({
+                        class: (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)(mirror() && __WEBPACK_EXTERNAL_MODULE__VideoPreview_classes_js_991e0adc__.CLASSES.mirror, local.class, local.className)
+                    }), {
                     get style () {
                         return local.style;
                     }

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/FormContext.d.ts

@@ -0,0 +1,16 @@
+import type { FormApi } from "./createForm";
+export type AnyFormApi = FormApi<any>;
+export declare const FormContext: import("solid-js").Context<AnyFormApi | null>;
+/**
+ * Reads the nearest `FormApi` from the component tree.
+ *
+ * Must be called inside a `<Form form={...}>` component. Throws a clear error
+ * in development if called outside a form context so the mistake is obvious
+ * rather than silently returning `undefined`.
+ *
+ * @example
+ * // Inside a component rendered as a child of <Form form={form}>
+ * const form = useFormContext();
+ * const tsForm = form._tsForm;
+ */
+export declare const useFormContext: () => AnyFormApi;

package/dist/hooks/form/FormContext.js

@@ -0,0 +1,8 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+const FormContext = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createContext)(null);
+const useFormContext = ()=>{
+    const ctx = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.useContext)(FormContext);
+    if (null === ctx) throw new Error("[pathscale/ui] useFormContext() was called outside of a <Form> component.\nMake sure this component is rendered as a descendant of <Form form={...}>.");
+    return ctx;
+};
+export { FormContext, useFormContext };