@pathscale/ui 1.2.1 → 1.2.3

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

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

@@ -0,0 +1,71 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+type AnyValues = Record<string, unknown>;
+export type AsyncValidatorFn<TValues extends AnyValues> = (context: {
+    value: TValues;
+}) => Promise<Partial<Record<keyof TValues, string>> | undefined>;
+export type CreateFormOptions<TValues extends AnyValues = AnyValues> = {
+    /**
+     * Initial values for every field. Used to infer the form's value type and
+     * to determine whether a field is "dirty".
+     */
+    defaultValues: TValues;
+    /**
+     * Any Standard Schema-compatible schema (Zod, Valibot, Arktype, ...).
+     * Applied as `validators.onChange`, `validators.onBlur` and
+     * `validators.onSubmit`.
+     */
+    schema?: StandardSchemaV1<TValues>;
+    /**
+     * Additional async validators for fields that need server-side validation
+     * (e.g. username availability). These run *after* the synchronous schema.
+     */
+    asyncValidators?: {
+        onBlur?: AsyncValidatorFn<TValues>;
+        onSubmit?: AsyncValidatorFn<TValues>;
+    };
+    /**
+     * Called when the form is submitted and all validators pass.
+     */
+    onSubmit?: (value: TValues) => void | Promise<void>;
+};
+/**
+ * The form API returned by `createForm`.
+ *
+ * Consumers should use `<Form form={api}>` to wire it into the component tree.
+ * For advanced use, access the raw TanStack Form instance via `api._tsForm`.
+ */
+export type FormApi<TValues extends AnyValues = AnyValues> = {
+    /**
+     * Raw TanStack Form instance. Intended as an escape hatch for cases not
+     * covered by the library's abstractions (custom field rendering, `<form.Subscribe>`, etc.).
+     * Prefixed with `_` to signal that it's an internal detail.
+     *
+     * TanStack Form's type has 12 generic parameters — we intentionally erase
+     * them here to keep the public API simple. Use `form._tsForm` to access the
+     * full typed instance in advanced scenarios.
+     */
+    _tsForm: any;
+    /** Phantom field: preserves TValues for type inference in consuming hooks. */
+    _values?: TValues;
+};
+/**
+ * Creates a new form instance backed by TanStack Form.
+ *
+ * ```tsx
+ * const form = createForm({
+ *   defaultValues: { email: "", password: "" },
+ *   schema: loginSchema,          // Zod or Valibot — both work
+ *   onSubmit: async (values) => { await login(values); },
+ * });
+ *
+ * return (
+ *   <Form form={form}>
+ *     <FormField name="email" label="Email" />
+ *     <FormField name="password" label="Password" inputProps={{ type: "password" }} />
+ *     <FormSubmitButton>Log in</FormSubmitButton>
+ *   </Form>
+ * );
+ * ```
+ */
+export declare const createForm: <TValues extends AnyValues = AnyValues>(options: CreateFormOptions<TValues>) => FormApi<TValues>;
+export {};

package/dist/hooks/form/createForm.js

@@ -0,0 +1,93 @@
+import * as __WEBPACK_EXTERNAL_MODULE__tanstack_solid_form_5af81884__ from "@tanstack/solid-form";
+const createValidationLogic = (props)=>{
+    if (!props.validators) return props.runValidation({
+        validators: [],
+        form: props.form
+    });
+    const isAsync = props.event.async;
+    const onMountValidator = isAsync ? void 0 : {
+        fn: props.validators.onMount,
+        cause: "mount"
+    };
+    const onChangeValidator = {
+        fn: isAsync ? props.validators.onChangeAsync : props.validators.onChange,
+        cause: "change"
+    };
+    const onBlurValidator = {
+        fn: isAsync ? props.validators.onBlurAsync : props.validators.onBlur,
+        cause: "blur"
+    };
+    const onSubmitValidator = {
+        fn: isAsync ? props.validators.onSubmitAsync : props.validators.onSubmit,
+        cause: "submit"
+    };
+    const onServerValidator = isAsync ? void 0 : {
+        fn: ()=>void 0,
+        cause: "server"
+    };
+    switch(props.event.type){
+        case "mount":
+            return props.runValidation({
+                validators: [
+                    onMountValidator
+                ],
+                form: props.form
+            });
+        case "submit":
+            return props.runValidation({
+                validators: [
+                    onChangeValidator,
+                    onBlurValidator,
+                    onSubmitValidator,
+                    onServerValidator
+                ],
+                form: props.form
+            });
+        case "server":
+            return props.runValidation({
+                validators: [],
+                form: props.form
+            });
+        case "blur":
+            return props.runValidation({
+                validators: [
+                    onBlurValidator,
+                    onServerValidator
+                ],
+                form: props.form
+            });
+        case "change":
+            return props.runValidation({
+                validators: [
+                    onChangeValidator,
+                    onBlurValidator,
+                    onServerValidator
+                ],
+                form: props.form
+            });
+        default:
+            throw new Error(`Unknown validation event type: ${props.event.type}`);
+    }
+};
+const createForm = (options)=>{
+    const hasSchema = Boolean(options.schema);
+    const hasAsyncValidators = Boolean(options.asyncValidators);
+    const tsForm = (0, __WEBPACK_EXTERNAL_MODULE__tanstack_solid_form_5af81884__.createForm)(()=>({
+            defaultValues: options.defaultValues,
+            validators: hasSchema || hasAsyncValidators ? {
+                onChange: options.schema,
+                onBlur: options.schema,
+                onSubmit: options.schema,
+                onBlurAsync: options.asyncValidators?.onBlur,
+                onSubmitAsync: options.asyncValidators?.onSubmit
+            } : void 0,
+            validationLogic: createValidationLogic,
+            onSubmit: async ({ value })=>{
+                await options.onSubmit?.(value);
+            }
+        }));
+    return {
+        _tsForm: tsForm
+    };
+};
+export { createForm };

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

@@ -0,0 +1,9 @@
+/**
+ * Normalizes a TanStack Form `ValidationError[]` into the first displayable
+ * error string.
+ *
+ * TanStack Form stores errors as `(string | ZodIssue | ValibotIssue | ...)[]`
+ * depending on the schema library in use. This function collapses that union
+ * to a single `string | undefined` for display in field error components.
+ */
+export declare const getFirstFieldError: (errors: unknown[]) => string | undefined;

package/dist/hooks/form/getFirstFieldError.js

@@ -0,0 +1,19 @@
+const getFirstFieldError = (errors)=>{
+    if (!errors || 0 === errors.length) return;
+    for (const error of errors)if (error) {
+        if ("string" == typeof error) {
+            const trimmed = error.trim();
+            if (trimmed.length > 0) return trimmed;
+            continue;
+        }
+        if ("object" == typeof error) {
+            const maybeMessage = error.message;
+            if ("string" == typeof maybeMessage) {
+                const trimmed = maybeMessage.trim();
+                if (trimmed.length > 0) return trimmed;
+            }
+            continue;
+        }
+    }
+};
+export { getFirstFieldError };

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

@@ -0,0 +1,4 @@
+export { createForm, type CreateFormOptions, type FormApi } from "./createForm";
+export { FormContext, useFormContext, type AnyFormApi } from "./FormContext";
+export { useField, type UseFieldResult } from "./useFieldNew";
+export { getFirstFieldError } from "./getFirstFieldError";

package/dist/hooks/form/index.js

@@ -0,0 +1,10 @@
+import * as __WEBPACK_EXTERNAL_MODULE__createForm_js_8fe217ba__ from "./createForm.js";
+import * as __WEBPACK_EXTERNAL_MODULE__FormContext_js_47b39222__ from "./FormContext.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useFieldNew_js_75d863ae__ from "./useFieldNew.js";
+import * as __WEBPACK_EXTERNAL_MODULE__getFirstFieldError_js_285cebb2__ from "./getFirstFieldError.js";
+var __webpack_exports__FormContext = __WEBPACK_EXTERNAL_MODULE__FormContext_js_47b39222__.FormContext;
+var __webpack_exports__createForm = __WEBPACK_EXTERNAL_MODULE__createForm_js_8fe217ba__.createForm;
+var __webpack_exports__getFirstFieldError = __WEBPACK_EXTERNAL_MODULE__getFirstFieldError_js_285cebb2__.getFirstFieldError;
+var __webpack_exports__useField = __WEBPACK_EXTERNAL_MODULE__useFieldNew_js_75d863ae__.useField;
+var __webpack_exports__useFormContext = __WEBPACK_EXTERNAL_MODULE__FormContext_js_47b39222__.useFormContext;
+export { __webpack_exports__FormContext as FormContext, __webpack_exports__createForm as createForm, __webpack_exports__getFirstFieldError as getFirstFieldError, __webpack_exports__useField as useField, __webpack_exports__useFormContext as useFormContext };

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

@@ -0,0 +1,35 @@
+import { type Accessor } from "solid-js";
+export type UseFieldResult = {
+    /** Current field value as an unknown (cast as needed). */
+    value: Accessor<unknown>;
+    /** Normalized first error string, gated by `isTouched`. `undefined` if clean. */
+    error: Accessor<string | undefined>;
+    /** Whether the field has been blurred at least once. */
+    touched: Accessor<boolean>;
+    /** `true` when `error()` is non-empty. */
+    invalid: Accessor<boolean>;
+    /** Call when the field value changes (accepts the new value directly). */
+    handleChange: (value: unknown) => void;
+    /** Call when the field loses focus. */
+    handleBlur: () => void;
+};
+/**
+ * Reads live field state for `name` from the nearest `<Form>` context.
+ *
+ * Must be called **inside** a `<Form form={...}>` descendant component.
+ * For fields that need fine-grained rendering, prefer using `form._tsForm.Field`
+ * render prop directly.
+ *
+ * ```tsx
+ * // Inside a child of <Form form={form}>
+ * const email = useField("email");
+ *
+ * <Input
+ *   value={String(email.value() ?? "")}
+ *   onInput={(e) => email.handleChange(e.currentTarget.value)}
+ *   onBlur={email.handleBlur}
+ *   aria-invalid={email.invalid()}
+ * />
+ * ```
+ */
+export declare const useField: (name: string) => UseFieldResult;

package/dist/hooks/form/useFieldNew.js

@@ -0,0 +1,31 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+import * as __WEBPACK_EXTERNAL_MODULE__FormContext_js_47b39222__ from "./FormContext.js";
+import * as __WEBPACK_EXTERNAL_MODULE__getFirstFieldError_js_285cebb2__ from "./getFirstFieldError.js";
+const useField = (name)=>{
+    const form = (0, __WEBPACK_EXTERNAL_MODULE__FormContext_js_47b39222__.useFormContext)();
+    const tsForm = form._tsForm;
+    const value = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>tsForm.getFieldValue(name));
+    const meta = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>tsForm.getFieldMeta(name));
+    const touched = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>Boolean(meta()?.isTouched));
+    const error = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>{
+        const m = meta();
+        if (!m?.isTouched) return;
+        return (0, __WEBPACK_EXTERNAL_MODULE__getFirstFieldError_js_285cebb2__.getFirstFieldError)(m.errors ?? []);
+    });
+    const invalid = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>Boolean(error()));
+    const handleChange = (value)=>{
+        tsForm.setFieldValue(name, value);
+    };
+    const handleBlur = ()=>{
+        tsForm.validateField(name, "blur");
+    };
+    return {
+        value,
+        error,
+        touched,
+        invalid,
+        handleChange,
+        handleBlur
+    };
+};
+export { useField };

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

@@ -0,0 +1 @@
+export { useDesktop } from "./useDesktop";

package/dist/hooks/layout/index.js

@@ -0,0 +1,3 @@
+import * as __WEBPACK_EXTERNAL_MODULE__useDesktop_js_7b1ad223__ from "./useDesktop.js";
+var __webpack_exports__useDesktop = __WEBPACK_EXTERNAL_MODULE__useDesktop_js_7b1ad223__.useDesktop;
+export { __webpack_exports__useDesktop as useDesktop };

package/dist/hooks/layout/useDesktop.d.ts

@@ -0,0 +1 @@
+export declare function useDesktop(breakpoint?: number): import("solid-js").Accessor<boolean>;

package/dist/hooks/layout/useDesktop.js

@@ -0,0 +1,17 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+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 { useDesktop };

package/dist/hooks/table/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { Accessor } from "solid-js";
+import type { SortingState, Updater } from "@tanstack/solid-table";
+import type { HookSortDescriptor } from "./useTableSorting";
+export declare const resolveUpdater: <T>(previous: T, updater: Updater<T>) => T;
+export declare const asAccessor: <T>(value: Accessor<T> | T) => Accessor<T>;
+export declare const toSortDescriptor: (sorting: SortingState) => HookSortDescriptor | undefined;
+export declare const toSortingState: (descriptor: HookSortDescriptor | undefined) => SortingState;

package/dist/hooks/table/helpers.js

@@ -0,0 +1,26 @@
+const resolveUpdater = (previous, updater)=>{
+    if ("function" == typeof updater) return updater(previous);
+    return updater;
+};
+const asAccessor = (value)=>{
+    if ("function" == typeof value) return value;
+    return ()=>value;
+};
+const toSortDescriptor = (sorting)=>{
+    const activeSort = sorting[0];
+    if (!activeSort) return;
+    return {
+        column: activeSort.id,
+        direction: activeSort.desc ? "descending" : "ascending"
+    };
+};
+const toSortingState = (descriptor)=>{
+    if (!descriptor) return [];
+    return [
+        {
+            id: descriptor.column,
+            desc: "descending" === descriptor.direction
+        }
+    ];
+};
+export { asAccessor, resolveUpdater, toSortDescriptor, toSortingState };