@pathscale/ui 1.2.1 → 1.2.2

package/dist/components/tooltip/Tooltip.js

@@ -2,7 +2,9 @@ import * as __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__ from "solid-js/web
 import "./Tooltip.css";
 import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
 import * as __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__ from "tailwind-merge";
-var _tmpl$ = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.template)("<span data-slot=tooltip-root>"), _tmpl$2 = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.template)("<div>"), _tmpl$3 = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.template)('<svg aria-hidden=true data-slot=tooltip-arrow-svg height=12 viewBox="0 0 12 12"width=12 xmlns=http://www.w3.org/2000/svg><path d="M0 0C5.48483 8 6.5 8 12 0Z"fill=currentColor>'), _tmpl$4 = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.template)("<span>");
+import * as __WEBPACK_EXTERNAL_MODULE__shared_overlayPosition_js_ab299723__ from "../_shared/overlayPosition.js";
+import * as __WEBPACK_EXTERNAL_MODULE__Tooltip_classes_js_59536676__ from "./Tooltip.classes.js";
+var _tmpl$ = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.template)("<span>"), _tmpl$2 = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.template)("<div>"), _tmpl$3 = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.template)('<svg aria-hidden=true data-slot=tooltip-arrow-svg height=12 viewBox="0 0 12 12"width=12 xmlns=http://www.w3.org/2000/svg><path d="M0 0C5.48483 8 6.5 8 12 0Z"fill=currentColor>');
 const TooltipContext = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createContext)();
 const useTooltipContext = ()=>{
     const ctx = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.useContext)(TooltipContext);
@@ -13,6 +15,8 @@ const TooltipRoot = (props)=>{
     const [local, _others] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.splitProps)(props, [
         "children",
         "placement",
+        "autoFlip",
+        "sideOffset",
         "showArrow",
         "delay",
         "closeDelay",
@@ -26,36 +30,63 @@ const TooltipRoot = (props)=>{
     ]);
     const [internalOpen, setInternalOpen] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)(Boolean(local.defaultOpen));
     const [triggerRef, setTriggerRef] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)();
+    const [contentRef, setContentRef] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)();
+    const [resolvedPlacement, setResolvedPlacement] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)(local.placement ?? "top");
+    let delayTimer;
+    let closeTimer;
     const isControlled = ()=>void 0 !== local.isOpen;
     const isOpen = ()=>isControlled() ? Boolean(local.isOpen) : internalOpen();
     const setIsOpen = (v)=>{
         if (!isControlled()) setInternalOpen(v);
         local.onOpenChange?.(v);
     };
+    const openTooltip = ()=>{
+        clearTimeout(closeTimer);
+        clearTimeout(delayTimer);
+        delayTimer = setTimeout(()=>setIsOpen(true), local.delay ?? 0);
+    };
+    const closeTooltip = ()=>{
+        clearTimeout(delayTimer);
+        clearTimeout(closeTimer);
+        closeTimer = setTimeout(()=>setIsOpen(false), local.closeDelay ?? 100);
+    };
+    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.onCleanup)(()=>{
+        clearTimeout(delayTimer);
+        clearTimeout(closeTimer);
+    });
     const ctx = {
         isOpen,
         setIsOpen,
-        placement: ()=>local.placement ?? "top",
+        openTooltip,
+        closeTooltip,
+        preferredPlacement: ()=>local.placement ?? "top",
+        placement: ()=>resolvedPlacement(),
+        setPlacement: setResolvedPlacement,
+        autoFlip: ()=>local.autoFlip ?? true,
+        sideOffset: ()=>local.sideOffset ?? 12,
         showArrow: ()=>Boolean(local.showArrow),
         triggerRef,
-        setTriggerRef
+        setTriggerRef,
+        contentRef,
+        setContentRef,
+        dataTheme: ()=>local.dataTheme
     };
     return (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.createComponent)(TooltipContext.Provider, {
         value: ctx,
         get children () {
             var _el$ = _tmpl$();
+            (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.spread)(_el$, (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.mergeProps)(()=>({
+                    class: (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)(__WEBPACK_EXTERNAL_MODULE__Tooltip_classes_js_59536676__.CLASSES.base, local.class, local.className)
+                }), {
+                "data-slot": "tooltip-root",
+                get ["data-theme"] () {
+                    return local.dataTheme;
+                },
+                get style () {
+                    return local.style;
+                }
+            }), false, true);
             (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.insert)(_el$, ()=>local.children);
-            (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.effect)((_p$)=>{
-                var _v$ = (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)("tooltip", local.class, local.className), _v$2 = local.dataTheme, _v$3 = local.style;
-                _v$ !== _p$.e && (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.className)(_el$, _p$.e = _v$);
-                _v$2 !== _p$.t && (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.setAttribute)(_el$, "data-theme", _p$.t = _v$2);
-                _p$.a = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.style)(_el$, _v$3, _p$.a);
-                return _p$;
-            }, {
-                e: void 0,
-                t: void 0,
-                a: void 0
-            });
             return _el$;
         }
     });
@@ -73,24 +104,16 @@ const TooltipTrigger = (props)=>{
         "onFocusOut"
     ]);
     const ctx = useTooltipContext();
-    let delayTimer;
-    let closeTimer;
-    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.onCleanup)(()=>{
-        clearTimeout(delayTimer);
-        clearTimeout(closeTimer);
-    });
     const handleMouseEnter = (e)=>{
-        clearTimeout(closeTimer);
-        ctx.setIsOpen(true);
+        ctx.openTooltip();
         if ("function" == typeof local.onMouseEnter) local.onMouseEnter(e);
     };
     const handleMouseLeave = (e)=>{
-        closeTimer = setTimeout(()=>ctx.setIsOpen(false), 100);
+        ctx.closeTooltip();
         if ("function" == typeof local.onMouseLeave) local.onMouseLeave(e);
     };
     const handleFocusIn = (e)=>{
-        clearTimeout(closeTimer);
-        ctx.setIsOpen(true);
+        ctx.openTooltip();
         if ("function" == typeof local.onFocusIn) local.onFocusIn(e);
     };
     const handleFocusOut = (e)=>{
@@ -100,10 +123,9 @@ const TooltipTrigger = (props)=>{
     return (()=>{
         var _el$2 = _tmpl$2();
         (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.use)((el)=>ctx.setTriggerRef(el), _el$2);
-        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.spread)(_el$2, (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.mergeProps)(others, {
-            get ["class"] () {
-                return (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)("tooltip__trigger", local.class, local.className);
-            },
+        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.spread)(_el$2, (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.mergeProps)(others, ()=>({
+                class: (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)(__WEBPACK_EXTERNAL_MODULE__Tooltip_classes_js_59536676__.CLASSES.slot.trigger, local.class, local.className)
+            }), {
             "data-slot": "tooltip-trigger",
             get ["data-theme"] () {
                 return local.dataTheme;
@@ -126,33 +148,78 @@ const TooltipContent = (props)=>{
         "class",
         "className",
         "dataTheme",
-        "style"
+        "style",
+        "onMouseEnter",
+        "onMouseLeave"
     ]);
     const ctx = useTooltipContext();
-    return (()=>{
-        var _el$3 = _tmpl$2();
-        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.spread)(_el$3, (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.mergeProps)(others, {
-            role: "tooltip",
-            get ["class"] () {
-                return (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)("tooltip__content", local.class, local.className);
-            },
-            "data-slot": "tooltip-content",
-            get ["data-placement"] () {
-                return ctx.placement();
-            },
-            get ["data-open"] () {
-                return ctx.isOpen() ? "true" : "false";
-            },
-            get ["data-theme"] () {
-                return local.dataTheme;
-            },
-            get style () {
-                return local.style;
-            }
-        }), false, true);
-        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.insert)(_el$3, ()=>local.children);
-        return _el$3;
-    })();
+    const overlayPosition = (0, __WEBPACK_EXTERNAL_MODULE__shared_overlayPosition_js_ab299723__.createOverlayPosition)({
+        open: ctx.isOpen,
+        triggerRef: ctx.triggerRef,
+        overlayRef: ctx.contentRef,
+        placement: ctx.preferredPlacement,
+        offset: ctx.sideOffset,
+        autoFlip: ctx.autoFlip,
+        align: ()=>"center"
+    });
+    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createEffect)(()=>{
+        ctx.setPlacement(overlayPosition.placement());
+    });
+    const style = ()=>{
+        const overlayStyle = overlayPosition.style();
+        if ("string" == typeof local.style) return [
+            local.style,
+            Object.entries(overlayStyle).map(([key, value])=>`${key}: ${String(value)}`).join("; ")
+        ].filter(Boolean).join("; ");
+        return {
+            ...local.style ?? {},
+            ...overlayStyle
+        };
+    };
+    const handleMouseEnter = (event)=>{
+        ctx.openTooltip();
+        if ("function" == typeof local.onMouseEnter) local.onMouseEnter(event);
+    };
+    const handleMouseLeave = (event)=>{
+        ctx.closeTooltip();
+        if ("function" == typeof local.onMouseLeave) local.onMouseLeave(event);
+    };
+    return (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.createComponent)(__WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.Show, {
+        get when () {
+            return ctx.isOpen();
+        },
+        get children () {
+            return (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.createComponent)(__WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.Portal, {
+                get children () {
+                    var _el$3 = _tmpl$2();
+                    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.use)((el)=>ctx.setContentRef(el), _el$3);
+                    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.spread)(_el$3, (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.mergeProps)(others, {
+                        role: "tooltip"
+                    }, ()=>({
+                            class: (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)(__WEBPACK_EXTERNAL_MODULE__Tooltip_classes_js_59536676__.CLASSES.slot.content, local.class, local.className)
+                        }), {
+                        "data-slot": "tooltip-content",
+                        get ["data-placement"] () {
+                            return ctx.placement();
+                        },
+                        get ["data-open"] () {
+                            return ctx.isOpen() ? "true" : "false";
+                        },
+                        get ["data-theme"] () {
+                            return local.dataTheme ?? ctx.dataTheme();
+                        },
+                        get style () {
+                            return style();
+                        },
+                        onMouseEnter: handleMouseEnter,
+                        onMouseLeave: handleMouseLeave
+                    }), false, true);
+                    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.insert)(_el$3, ()=>local.children);
+                    return _el$3;
+                }
+            });
+        }
+    });
 };
 const TooltipArrow = (props)=>{
     const [local, others] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.splitProps)(props, [
@@ -165,11 +232,10 @@ const TooltipArrow = (props)=>{
     const ctx = useTooltipContext();
     const defaultArrow = _tmpl$3();
     return (()=>{
-        var _el$5 = _tmpl$4();
-        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.spread)(_el$5, (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.mergeProps)(others, {
-            get ["class"] () {
-                return (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)("tooltip__arrow", local.class, local.className);
-            },
+        var _el$5 = _tmpl$();
+        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.spread)(_el$5, (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.mergeProps)(others, ()=>({
+                class: (0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)(__WEBPACK_EXTERNAL_MODULE__Tooltip_classes_js_59536676__.CLASSES.slot.arrow, local.class, local.className)
+            }), {
             "data-slot": "tooltip-arrow",
             get ["data-placement"] () {
                 return ctx.placement();

package/dist/components/utils.d.ts

@@ -1,9 +1,9 @@
-import { type JSX } from "solid-js";
+import type { JSX } from "solid-js";
 import type { ResponsiveProp } from "./types";
+export { useDesktop } from "../hooks/layout";
 export declare function wrapWithElementIfInvalid({ node, wrapper, className, }: {
     node: JSX.Element | string | number | null | undefined;
     wrapper?: keyof JSX.IntrinsicElements;
     className?: string;
 }): JSX.Element;
 export declare function mapResponsiveProp<T extends string | boolean>(prop: ResponsiveProp<T> | undefined, classMap: Record<string, string>): string[];
-export declare function useDesktop(breakpoint?: number): import("solid-js").Accessor<boolean>;

package/dist/components/utils.js

@@ -1,16 +1,18 @@
 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__types_js_7eec16d2__ from "./types.js";
+import * as __WEBPACK_EXTERNAL_MODULE__hooks_layout_index_js_ad74a5db__ from "../hooks/layout/index.js";
 function isJSXElement(node) {
     return "object" == typeof node && null !== node;
 }
 function wrapWithElementIfInvalid({ node, wrapper = "div", className = "" }) {
     null == node || "string" == typeof node || "number" == typeof node || isJSXElement(node);
-    return (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.createComponent)(__WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.Dynamic, {
-        component: wrapper,
-        class: className,
+    return (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.createComponent)(__WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.Dynamic, (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.mergeProps)({
+        component: wrapper
+    }, {
+        class: className
+    }, {
         children: node
-    });
+    }));
 }
 function mapResponsiveProp(prop, classMap) {
     if (void 0 === prop) return [];
@@ -28,19 +30,5 @@ function mapResponsiveProp(prop, classMap) {
         ];
     });
 }
-function useDesktop(breakpoint = 1024) {
-    const [isDesktop, setIsDesktop] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createSignal)(false);
-    const checkIfDesktop = ()=>{
-        const width = window.innerWidth;
-        setIsDesktop(width >= breakpoint);
-    };
-    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.onMount)(()=>{
-        checkIfDesktop();
-        window.addEventListener("resize", checkIfDesktop);
-    });
-    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.onCleanup)(()=>{
-        window.removeEventListener("resize", checkIfDesktop);
-    });
-    return isDesktop;
-}
-export { mapResponsiveProp, useDesktop, wrapWithElementIfInvalid };
+var __webpack_exports__useDesktop = __WEBPACK_EXTERNAL_MODULE__hooks_layout_index_js_ad74a5db__.useDesktop;
+export { mapResponsiveProp, wrapWithElementIfInvalid, __webpack_exports__useDesktop as useDesktop };

package/dist/components/video-preview/VideoPreview.classes.d.ts

@@ -0,0 +1,3 @@
+export declare const CLASSES: {
+    readonly mirror: "-scale-x-100";
+};

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

@@ -0,0 +1,4 @@
+const CLASSES = {
+    mirror: "-scale-x-100"
+};
+export { CLASSES };

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 {};