@pathscale/ui 2.5.0 → 2.6.0

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

@@ -6,16 +6,16 @@ type CalendarNavigationOptions = {
     isDateDisabled: (date: Date) => boolean;
 };
 export declare const useCalendarNavigation: (options: CalendarNavigationOptions) => {
-    visibleMonth: Accessor<Date>;
-    focusedDate: Accessor<Date>;
+    visibleMonth: import("solid-js").SourceAccessor<Date>;
+    focusedDate: import("solid-js").SourceAccessor<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>;
+    canNavigatePrevious: import("solid-js").SourceAccessor<boolean>;
+    canNavigateNext: import("solid-js").SourceAccessor<boolean>;
     syncFocusedDate: (value: Date | null) => void;
 };
 export {};

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

@@ -28,15 +28,15 @@ export type CalendarCellState = {
     isAriaSelected: boolean;
 };
 export declare const useCalendarState: (options: CalendarStateOptions) => {
-    monthFormatter: Accessor<Intl.DateTimeFormat>;
-    dayLabelFormatter: Accessor<Intl.DateTimeFormat>;
-    weekdayLabels: Accessor<string[]>;
-    calendarWeeks: Accessor<Date[][]>;
-    normalizedRange: Accessor<{
+    monthFormatter: import("solid-js").SourceAccessor<Intl.DateTimeFormat>;
+    dayLabelFormatter: import("solid-js").SourceAccessor<Intl.DateTimeFormat>;
+    weekdayLabels: import("solid-js").SourceAccessor<string[]>;
+    calendarWeeks: import("solid-js").SourceAccessor<Date[][]>;
+    normalizedRange: import("solid-js").SourceAccessor<{
         start: Date | null;
         end: Date | null;
     }>;
-    previewRange: Accessor<{
+    previewRange: import("solid-js").SourceAccessor<{
         start: Date | null;
         end: Date | null;
     }>;

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

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

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

@@ -6,8 +6,8 @@ type PickerOpenStateOptions = {
     isDisabled: Accessor<boolean>;
 };
 export declare const usePickerOpenState: (options: PickerOpenStateOptions) => {
-    isOpen: Accessor<boolean>;
-    isControlled: Accessor<boolean>;
+    isOpen: import("solid-js").SourceAccessor<boolean>;
+    isControlled: import("solid-js").SourceAccessor<boolean>;
     setOpen: (nextOpen: boolean) => void;
     toggleOpen: () => void;
     setRootRef: import("solid-js").Setter<HTMLElement | undefined>;

package/dist/hooks/date/usePickerOpenState.js

@@ -1,4 +1,4 @@
-import { createEffect, createMemo, createSignal, onCleanup, onMount } from "solid-js";
+import { createEffect, createMemo, createSignal, onCleanup, onSettled } from "solid-js";
 const usePickerOpenState = (options)=>{
     const [internalOpen, setInternalOpen] = createSignal(Boolean(options.defaultOpen()));
     const [rootRef, setRootRef] = createSignal(void 0);
@@ -13,7 +13,7 @@ const usePickerOpenState = (options)=>{
     const toggleOpen = ()=>{
         setOpen(!isOpen());
     };
-    onMount(()=>{
+    onSettled(()=>{
         const handlePointerDown = (event)=>{
             if (!isOpen()) return;
             const root = rootRef();

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

@@ -7,17 +7,17 @@ type RangeSelectionOptions = {
     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<{
+    isControlled: import("solid-js").SourceAccessor<boolean>;
+    isSelectingEnd: import("solid-js").SourceAccessor<boolean>;
+    committedRange: import("solid-js").SourceAccessor<DateRangeValue | null>;
+    hoveredDate: import("solid-js").SourceAccessor<Date | null>;
+    rangeStart: import("solid-js").SourceAccessor<Date | null>;
+    rangeEnd: import("solid-js").SourceAccessor<Date | null>;
+    previewRange: import("solid-js").SourceAccessor<{
         start: Date | null;
         end: Date | null;
     }>;
-    focusDate: Accessor<Date | null>;
+    focusDate: import("solid-js").SourceAccessor<Date | null>;
     selectDate: (value: Date) => void;
     setCommittedRange: (nextValue: ControlledDateRangeValue) => void;
     setHoverDate: (value: Date | undefined) => void;

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

@@ -11,6 +11,6 @@ export declare const FormContext: import("solid-js").Context<AnyFormApi | null>;
  * @example
  * // Inside a component rendered as a child of <Form form={form}>
  * const form = useFormContext();
- * const tsForm = form._tsForm;
+ * const value = form.getFieldValue("email");
  */
 export declare const useFormContext: () => AnyFormApi;

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

@@ -1,5 +1,6 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-type AnyValues = Record<string, unknown>;
+import { getFirstFieldError } from "./getFirstFieldError";
+type AnyValues = Record<string, any>;
 export type AsyncValidatorFn<TValues extends AnyValues> = (context: {
     value: TValues;
 }) => Promise<Partial<Record<keyof TValues, string>> | undefined>;
@@ -11,8 +12,7 @@ export type CreateFormOptions<TValues extends AnyValues = AnyValues> = {
     defaultValues: TValues;
     /**
      * Any Standard Schema-compatible schema (Zod, Valibot, Arktype, ...).
-     * Applied as `validators.onChange`, `validators.onBlur` and
-     * `validators.onSubmit`.
+     * Runs on change, on blur and on submit.
      */
     schema?: StandardSchemaV1<TValues>;
     /**
@@ -28,44 +28,54 @@ export type CreateFormOptions<TValues extends AnyValues = AnyValues> = {
      */
     onSubmit?: (value: TValues) => void | Promise<void>;
 };
+/** What a field tracks besides its value. */
+type FieldMeta = {
+    isTouched: boolean;
+    errors: string[];
+};
 /**
  * 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`.
+ * Consumers should use `<Form form={api}>` to wire it into the component tree,
+ * and read individual fields with `useField(name)`.
  */
 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;
+    /** Every field's current value. */
+    values: () => TValues;
+    /** One field's current value. */
+    getFieldValue: (name: string) => unknown;
+    /** One field's touched flag and errors. */
+    getFieldMeta: (name: string) => FieldMeta;
+    /** Write a value and re-run the synchronous schema. */
+    setFieldValue: (name: string, value: unknown) => void;
+    /** Mark touched and validate, which is what a blur means. */
+    validateField: (name: string, cause: "change" | "blur") => void | Promise<void>;
+    /** Validate everything, run async validators, then `onSubmit` if clean. */
+    submit: () => Promise<void>;
+    /** True while `submit()` is awaiting. */
+    isSubmitting: () => boolean;
+    /** True when no field holds an error. */
+    isValid: () => boolean;
     /** Phantom field: preserves TValues for type inference in consuming hooks. */
     _values?: TValues;
 };
 /**
- * Creates a new form instance backed by TanStack Form.
+ * A form, without TanStack.
+ *
+ * The engine is deliberately small because the field components already carry
+ * the hard parts: `Input`, `Select`, `Checkbox` and the rest own their own
+ * presentation, `state="invalid"` and error slot. What was missing is
+ * bookkeeping — values, touched, errors, and when to run the schema — and that
+ * is what this is.
  *
- * ```tsx
- * const form = createForm({
- *   defaultValues: { email: "", password: "" },
- *   schema: loginSchema,          // Zod or Valibot — both work
- *   onSubmit: async (values) => { await login(values); },
- * });
+ * `@tanstack/solid-form` used to supply it, through a `_tsForm` escape hatch
+ * that leaked its twelve erased generics into this library's public type. It
+ * also peer-pinned Solid 1, which made it one of three packages standing
+ * between this library and Solid 2.
  *
- * return (
- *   <Form form={form}>
- *     <FormField name="email" label="Email" />
- *     <FormField name="password" label="Password" inputProps={{ type: "password" }} />
- *     <FormSubmitButton>Log in</FormSubmitButton>
- *   </Form>
- * );
- * ```
+ * Validation runs on change and on blur, and errors are only *shown* once a
+ * field is touched — the display gate lives in `useField`, so a submit can
+ * surface every error at once by touching every field.
  */
 export declare const createForm: <TValues extends AnyValues = AnyValues>(options: CreateFormOptions<TValues>) => FormApi<TValues>;
-export {};
+export { getFirstFieldError };

package/dist/hooks/form/createForm.js

@@ -1,93 +1,118 @@
-import { createForm } from "@tanstack/solid-form";
-const createValidationLogic = (props)=>{
-    if (!props.validators) return props.runValidation({
-        validators: [],
-        form: props.form
+import { createStore, flush } from "solid-js";
+const issuesToErrors = (issues)=>{
+    const errors = {};
+    for (const issue of issues){
+        const head = issue.path?.[0];
+        const name = "object" == typeof head && null !== head && "key" in head ? String(head.key) : String(head ?? "");
+        if (name) (errors[name] ??= []).push(issue.message);
+    }
+    return errors;
+};
+const createForm = (options)=>{
+    const [values, setValues] = createStore({
+        ...options.defaultValues
     });
-    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 [meta, setMeta] = createStore({});
+    const [status, setStatus] = createStore({
+        isSubmitting: false
+    });
+    const metaFor = (name)=>meta[name] ?? {
+            isTouched: false,
+            errors: []
+        };
+    const applyErrors = (errors, touchAll)=>{
+        setMeta((draft)=>{
+            for (const name of new Set([
+                ...Object.keys(draft),
+                ...Object.keys(errors)
+            ]))draft[name] = {
+                isTouched: touchAll || (draft[name]?.isTouched ?? false),
+                errors: errors[name] ?? []
+            };
+        });
+        flush();
     };
-    const onSubmitValidator = {
-        fn: isAsync ? props.validators.onSubmitAsync : props.validators.onSubmit,
-        cause: "submit"
+    const runSchema = ()=>{
+        const schema = options.schema;
+        if (!schema) return true;
+        const result = schema["~standard"].validate(values);
+        if (result instanceof Promise) return true;
+        applyErrors(result.issues ? issuesToErrors(result.issues) : {}, false);
+        return !result.issues?.length;
     };
-    const onServerValidator = isAsync ? void 0 : {
-        fn: ()=>void 0,
-        cause: "server"
+    const setFieldValue = (name, value)=>{
+        setValues((draft)=>{
+            draft[name] = value;
+        });
+        flush();
+        runSchema();
     };
-    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
+    const validateField = (name, cause)=>{
+        if ("blur" === cause) {
+            setMeta((draft)=>{
+                draft[name] = {
+                    isTouched: true,
+                    errors: draft[name]?.errors ?? []
+                };
             });
-        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_createForm = (options)=>{
-    const hasSchema = Boolean(options.schema);
-    const hasAsyncValidators = Boolean(options.asyncValidators);
-    const tsForm = 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);
+            flush();
+        }
+        runSchema();
+    };
+    const submit = async ()=>{
+        setMeta((draft)=>{
+            for (const name of Object.keys(values))draft[name] = {
+                isTouched: true,
+                errors: draft[name]?.errors ?? []
+            };
+        });
+        flush();
+        let ok = runSchema();
+        const schema = options.schema;
+        if (schema) {
+            const result = schema["~standard"].validate(values);
+            if (result instanceof Promise) {
+                const resolved = await result;
+                applyErrors(resolved.issues ? issuesToErrors(resolved.issues) : {}, true);
+                ok = !resolved.issues?.length;
             }
-        }));
+        }
+        if (!ok) return;
+        setStatus((draft)=>{
+            draft.isSubmitting = true;
+        });
+        try {
+            const asyncSubmit = options.asyncValidators?.onSubmit;
+            if (asyncSubmit) {
+                const serverErrors = await asyncSubmit({
+                    value: values
+                });
+                if (serverErrors && Object.keys(serverErrors).length > 0) return void setMeta((draft)=>{
+                    for (const [name, message] of Object.entries(serverErrors))if (message) draft[name] = {
+                        isTouched: true,
+                        errors: [
+                            String(message)
+                        ]
+                    };
+                });
+            }
+            await options.onSubmit?.(values);
+        } finally{
+            setStatus((draft)=>{
+                draft.isSubmitting = false;
+            });
+        }
+    };
     return {
-        _tsForm: tsForm
+        values: ()=>values,
+        getFieldValue: (name)=>values[name],
+        getFieldMeta: metaFor,
+        setFieldValue,
+        validateField,
+        submit,
+        isSubmitting: ()=>status.isSubmitting,
+        isValid: ()=>Object.values(meta).every((m)=>(m?.errors.length ?? 0) === 0)
     };
 };
-export { createForm_createForm as createForm };
+export { getFirstFieldError } from "./getFirstFieldError.js";
+export { createForm };

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

@@ -17,8 +17,8 @@ export type UseFieldResult = {
  * 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.
+ * Field components own their own presentation; this supplies the state they
+ * need to show it.
  *
  * ```tsx
  * // Inside a child of <Form form={form}>
@@ -28,7 +28,7 @@ export type UseFieldResult = {
  *   value={String(email.value() ?? "")}
  *   onInput={(e) => email.handleChange(e.currentTarget.value)}
  *   onBlur={email.handleBlur}
- *   aria-invalid={email.invalid()}
+ *   aria-invalid={email.invalid() ? "true" : "false"}
  * />
  * ```
  */

package/dist/hooks/form/useFieldNew.js

@@ -3,22 +3,13 @@ import { useFormContext } from "./FormContext.js";
 import { getFirstFieldError } from "./getFirstFieldError.js";
 const useField = (name)=>{
     const form = useFormContext();
-    const tsForm = form._tsForm;
-    const value = createMemo(()=>tsForm.getFieldValue(name));
-    const meta = createMemo(()=>tsForm.getFieldMeta(name));
-    const touched = createMemo(()=>Boolean(meta()?.isTouched));
-    const error = createMemo(()=>{
-        const m = meta();
-        if (!m?.isTouched) return;
-        return getFirstFieldError(m.errors ?? []);
-    });
+    const value = createMemo(()=>form.getFieldValue(name));
+    const meta = createMemo(()=>form.getFieldMeta(name));
+    const touched = createMemo(()=>meta().isTouched);
+    const error = createMemo(()=>meta().isTouched ? getFirstFieldError(meta().errors) : void 0);
     const invalid = createMemo(()=>Boolean(error()));
-    const handleChange = (value)=>{
-        tsForm.setFieldValue(name, value);
-    };
-    const handleBlur = ()=>{
-        tsForm.validateField(name, "blur");
-    };
+    const handleChange = (next)=>form.setFieldValue(name, next);
+    const handleBlur = ()=>form.validateField(name, "blur");
     return {
         value,
         error,

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

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

package/dist/hooks/layout/useDesktop.js

@@ -1,11 +1,11 @@
-import { createSignal, onCleanup, onMount } from "solid-js";
+import { createSignal, onCleanup, onSettled } from "solid-js";
 function useDesktop(breakpoint = 1024) {
     const [isDesktop, setIsDesktop] = createSignal(false);
     const checkIfDesktop = ()=>{
         const width = window.innerWidth;
         setIsDesktop(width >= breakpoint);
     };
-    onMount(()=>{
+    onSettled(()=>{
         checkIfDesktop();
         window.addEventListener("resize", checkIfDesktop);
     });

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

@@ -1,9 +1,2 @@
-export { useTableSorting, type UseTableSortingOptions, type UseTableSortingResult, type HookSortDirection, type HookSortDescriptor, } from "./useTableSorting";
-export { useTablePagination, type UseTablePaginationOptions, type UseTablePaginationResult, } from "./useTablePagination";
-export { useTableFiltering, type UseTableFilteringOptions, type UseTableFilteringResult, } from "./useTableFiltering";
-export { useTableSelection, type UseTableSelectionOptions, type UseTableSelectionResult, type TableSelectionState, } from "./useTableSelection";
-export { useTableExpansion, type UseTableExpansionOptions, type UseTableExpansionResult, } from "./useTableExpansion";
-export { useTableModel, type UseTableModelOptions, } from "./useTableModel";
-export { toSortDescriptor, toSortingState } from "./helpers";
 export { useAnchoredOverlayPosition } from "./useAnchoredOverlayPosition";
 export type { UseAnchoredOverlayPositionOptions } from "./useAnchoredOverlayPosition";

package/dist/hooks/table/index.js

@@ -1,8 +1 @@
-export { useTableSorting } from "./useTableSorting.js";
-export { useTablePagination } from "./useTablePagination.js";
-export { useTableFiltering } from "./useTableFiltering.js";
-export { useTableSelection } from "./useTableSelection.js";
-export { useTableExpansion } from "./useTableExpansion.js";
-export { useTableModel } from "./useTableModel.js";
-export { toSortDescriptor, toSortingState } from "./helpers.js";
 export { useAnchoredOverlayPosition } from "./useAnchoredOverlayPosition.js";

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

@@ -1,4 +1,5 @@
-import { type Accessor, type JSX } from "solid-js";
+import { type Accessor } from "solid-js";
+import type { JSX } from "@solidjs/web";
 export interface UseAnchoredOverlayPositionOptions {
     isOpen: Accessor<boolean>;
     getAnchor: Accessor<HTMLElement | undefined>;
@@ -11,6 +12,6 @@ export interface UseAnchoredOverlayPositionOptions {
     zIndex?: number;
 }
 export declare const useAnchoredOverlayPosition: (options: UseAnchoredOverlayPositionOptions) => {
-    style: Accessor<JSX.CSSProperties>;
+    style: import("solid-js").SourceAccessor<JSX.CSSProperties>;
     updatePosition: () => void;
 };

package/dist/index.d.ts

@@ -98,8 +98,8 @@ export type { CreateDataGridOptions, DataGridCellContext, DataGridColumn, DataGr
 export { default as Table } from "./components/table";
 export { SortIcon as TableSortIcon, ExpandToggle as TableExpandToggle, VirtualSpacerRow as TableVirtualSpacerRow, MobileListView as TableMobileListView, InlineConfirm as TableInlineConfirm, } from "./components/table";
 export type { TableProps, TableSortDirection, TableSortDescriptor, TableColumnRenderProps, SortIconProps as TableSortIconProps, SortIconState as TableSortIconState, ExpandToggleProps as TableExpandToggleProps, VirtualSpacerRowProps as TableVirtualSpacerRowProps, MobileListViewProps as TableMobileListViewProps, InlineConfirmProps as TableInlineConfirmProps, InlineConfirmVariant as TableInlineConfirmVariant, } from "./components/table";
-export { useTableModel, useTableSorting, useTablePagination, useTableFiltering, useTableSelection, useTableExpansion, toSortDescriptor, toSortingState, useAnchoredOverlayPosition, } from "./hooks/table";
-export type { UseTableModelOptions, UseTableSortingOptions, UseTableSortingResult, HookSortDirection, HookSortDescriptor, UseTablePaginationOptions, UseTablePaginationResult, UseTableFilteringOptions, UseTableFilteringResult, UseTableSelectionOptions, UseTableSelectionResult, TableSelectionState, UseTableExpansionOptions, UseTableExpansionResult, UseAnchoredOverlayPositionOptions, } from "./hooks/table";
+export { useAnchoredOverlayPosition } from "./hooks/table";
+export type { UseAnchoredOverlayPositionOptions } from "./hooks/table";
 export { default as Tabs } from "./components/tabs";
 export type { TabsRootProps, TabListContainerProps, TabListProps, TabProps, TabIndicatorProps, TabSeparatorProps, TabPanelProps, } from "./components/tabs";
 export { default as Text } from "./components/text";
@@ -114,11 +114,9 @@ export { default as Switch } from "./components/switch";
 export { default as Tooltip, TooltipTrigger, TooltipContent, TooltipArrow, } from "./components/tooltip";
 export type { TooltipPlacement, TooltipRootProps, TooltipTriggerProps, TooltipContentProps, TooltipArrowProps, } from "./components/tooltip";
 export * from "./motion";
-export { useVirtualRows } from "./primitives/virtualizer";
-export type { UseVirtualRowsOptions, UseVirtualRowsResult, VirtualRowsRange, } from "./primitives/virtualizer";
 export { useStreamingBuffer, useStreamingSubscription, } from "./primitives/streaming";
 export type { StreamingBufferStrategy, StreamingSubscribeFn, StreamingSubscriptionObserver, UseStreamingBufferOptions, UseStreamingBufferResult, UseStreamingSubscriptionOptions, UseStreamingSubscriptionResult, } from "./primitives/streaming";
-export type { Flavor, State, Variant, Size, Radius, Space, Width, Height, MaxWidth, Align, Justify, Direction, UIBaseProps, IconSlotProps, Controlled, Issue, ErrorHandler, Failable, Constraint, Validate, ValidateOn, Validatable, OpenChangeReason, ChangeReason, Disclosable, CapabilityProps, } from "./components/vocabulary";
+export type { Flavor, State, Variant, Material, Size, Radius, Space, Width, Height, MaxWidth, Align, Justify, Direction, UIBaseProps, IconSlotProps, Controlled, Issue, ErrorHandler, Failable, Constraint, Validate, ValidateOn, Validatable, OpenChangeReason, ChangeReason, Disclosable, CapabilityProps, } from "./components/vocabulary";
 export { isInvalid, resolveState } from "./components/vocabulary";
 export { FLAVORS, STATES, VARIANTS, SIZES, SPACES } from "./components/vocabulary";
 export { default as InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator, REGEXP_ONLY_DIGITS, REGEXP_ONLY_CHARS, REGEXP_ONLY_DIGITS_AND_CHARS, } from "./components/input-otp";

package/dist/index.js

@@ -58,14 +58,13 @@ export { default as Slider } from "./components/slider/index.js";
 export { default as Skeleton } from "./components/skeleton/index.js";
 export { createDataGrid, default as DataGrid } from "./components/data-grid/index.js";
 export { ExpandToggle as TableExpandToggle, InlineConfirm as TableInlineConfirm, MobileListView as TableMobileListView, SortIcon as TableSortIcon, VirtualSpacerRow as TableVirtualSpacerRow, default as Table } from "./components/table/index.js";
-export { toSortDescriptor, toSortingState, useAnchoredOverlayPosition, useTableExpansion, useTableFiltering, useTableModel, useTablePagination, useTableSelection, useTableSorting } from "./hooks/table/index.js";
+export { useAnchoredOverlayPosition } from "./hooks/table/index.js";
 export { default as Tabs } from "./components/tabs/index.js";
 export { default as Text } from "./components/text/index.js";
 export { default as Textarea } from "./components/textarea/index.js";
 export { ThemeColorPicker, createHueShiftStore, getDefaultHueShiftStore, resetHueShift } from "./components/theme-color-picker/index.js";
 export { default as Switch } from "./components/switch/index.js";
 export { TooltipArrow, TooltipContent, TooltipTrigger, default as Tooltip } from "./components/tooltip/index.js";
-export { useVirtualRows } from "./primitives/virtualizer/index.js";
 export { useStreamingBuffer, useStreamingSubscription } from "./primitives/streaming/index.js";
 export { FLAVORS, SIZES, SPACES, STATES, VARIANTS, isInvalid, resolveState } from "./components/vocabulary.js";
 export { InputOTPGroup, InputOTPSeparator, InputOTPSlot, REGEXP_ONLY_CHARS, REGEXP_ONLY_DIGITS, REGEXP_ONLY_DIGITS_AND_CHARS, default as InputOTP } from "./components/input-otp/index.js";

package/dist/layouts.manifest.json

@@ -1,7 +1,7 @@
 {
   "format": "solid-layouts-library-v2",
   "package": "@pathscale/ui",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "components": {
     "Accordion": {
       "kind": "embedded"

package/dist/lib/layouts/index.d.ts

@@ -1 +1 @@
-export { compound, defineComponent, recipe, type DefineComponentConfig, type Layout, type PropsOf, type Recipe, type RecipeConfig, type SlotAttrs, type SlotsOf, type StateOf, } from "solid-layouts";
+export { compound, defineComponent, recipe, type DefineComponentConfig, type Layout, type PropsOf, type Recipe, type RecipeConfig, type SlotAttrs, type SlotsOf, type StateOf, } from "solid-layouts/solid-2";

package/dist/lib/layouts/index.js

@@ -1 +1 @@
-export { compound, defineComponent, recipe } from "solid-layouts";
+export { compound, defineComponent, recipe } from "solid-layouts/solid-2";

package/dist/lib/twMerge.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `twMerge`, accepting what Solid 2 says a `class` prop can be.
+ *
+ * 2.0 absorbed `classList` into `class`, so `JSX.HTMLAttributes["class"]` is now
+ * `ClassValue`: a string, a number, a boolean, `null`, an array of those, or a
+ * `Record<string, boolean>` of conditional names. `tailwind-merge` accepts most
+ * of that but not `number`, so every `twMerge(CLASSES.base, props.class)` in the
+ * library stopped typechecking — 287 call sites across 114 files, each one
+ * correct and each one now the wrong colour.
+ *
+ * Widening here rather than casting there. A cast at 287 sites is 287 chances
+ * to cast to the wrong thing, and it would leave no single place to say why.
+ *
+ * `Record<string, boolean>` is flattened to its truthy keys, which is what the
+ * old `classList` did with the same object. Numbers and booleans are dropped:
+ * `class={0}` and `class={false}` are how a conditional resolves to "nothing",
+ * and `tailwind-merge` has no meaning for them.
+ */
+type SolidClassValue = string | number | boolean | null | undefined | Record<string, boolean | undefined> | SolidClassValue[];
+export declare const twMerge: (...values: SolidClassValue[]) => string;
+export type { SolidClassValue };

package/dist/lib/twMerge.js

@@ -0,0 +1,12 @@
+import { twMerge } from "tailwind-merge";
+const flatten = (value)=>{
+    if (null == value) return [];
+    if ("string" == typeof value) return value ? [
+        value
+    ] : [];
+    if ("number" == typeof value || "boolean" == typeof value) return [];
+    if (Array.isArray(value)) return value.flatMap(flatten);
+    return Object.keys(value).filter((key)=>value[key]);
+};
+const twMerge_twMerge = (...values)=>twMerge(...values.flatMap(flatten));
+export { twMerge_twMerge as twMerge };