@proyecto-viviana/solid-stately 0.2.4 → 0.3.0

package/dist/combobox/createComboBoxState.d.ts

@@ -5,15 +5,15 @@
  * ComboBox combines a text input with a dropdown list, allowing users to
  * either type to filter options or select from a list.
  */
-import { type Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
-import type { Key, CollectionNode, Collection, FocusStrategy } from '../collections/types';
-export type MenuTriggerAction = 'focus' | 'input' | 'manual';
-export type { FocusStrategy } from '../collections/types';
+import { type Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
+import type { Key, CollectionNode, Collection, FocusStrategy } from "../collections/types";
+export type MenuTriggerAction = "focus" | "input" | "manual";
+export type { FocusStrategy } from "../collections/types";
 export type FilterFn = (textValue: string, inputValue: string) => boolean;
 export interface ComboBoxStateProps<T = unknown> {
     /** The items to display in the combobox dropdown. */
-    items: T[];
+    items?: T[];
     /** Default items when uncontrolled. */
     defaultItems?: T[];
     /** Function to get the key for an item. */
@@ -24,12 +24,20 @@ export interface ComboBoxStateProps<T = unknown> {
     getDisabled?: (item: T) => boolean;
     /** Keys of disabled items. */
     disabledKeys?: Iterable<Key>;
-    /** The currently selected key (controlled). */
+    /** The selection mode for the combobox. */
+    selectionMode?: "single" | "multiple";
+    /** The currently selected key (controlled, single mode). */
     selectedKey?: Key | null;
-    /** The default selected key (uncontrolled). */
+    /** The default selected key (uncontrolled, single mode). */
     defaultSelectedKey?: Key | null;
-    /** Handler called when the selection changes. */
+    /** The currently selected keys (controlled, multiple mode). */
+    selectedKeys?: Iterable<Key>;
+    /** The default selected keys (uncontrolled, multiple mode). */
+    defaultSelectedKeys?: Iterable<Key>;
+    /** Handler called when the selection changes (single mode). */
     onSelectionChange?: (key: Key | null) => void;
+    /** Handler called when the selection changes (multiple mode). */
+    onSelectionChangeMultiple?: (keys: Set<Key>) => void;
     /** The current input value (controlled). */
     inputValue?: string;
     /** The default input value (uncontrolled). */
@@ -70,14 +78,20 @@ export interface ComboBoxState<T = unknown> {
     close(): void;
     /** Toggle the combobox dropdown. */
     toggle(focusStrategy?: FocusStrategy | null, trigger?: MenuTriggerAction): void;
-    /** The currently selected key. */
+    /** The currently selected key (single mode). */
     readonly selectedKey: Accessor<Key | null>;
     /** The default selected key. */
     readonly defaultSelectedKey: Key | null;
-    /** The currently selected item. */
+    /** The currently selected item (single mode). */
     readonly selectedItem: Accessor<CollectionNode<T> | null>;
     /** Set the selected key. */
     setSelectedKey(key: Key | null): void;
+    /** The currently selected keys (multiple mode). */
+    readonly selectedKeys: Accessor<Set<Key>>;
+    /** The currently selected items (multiple mode). */
+    readonly selectedItems: Accessor<CollectionNode<T>[]>;
+    /** Remove a selected key (multiple mode). */
+    removeSelectedKey(key: Key): void;
     /** The current input value. */
     readonly inputValue: Accessor<string>;
     /** The default input value. */
@@ -102,8 +116,8 @@ export interface ComboBoxState<T = unknown> {
     isKeyDisabled(key: Key): boolean;
     /** Select a key and close the menu (for ListState compatibility). */
     select(key: Key): void;
-    /** The selection mode (always 'single' for combobox). */
-    readonly selectionMode: Accessor<'single'>;
+    /** The selection mode. */
+    readonly selectionMode: Accessor<"single" | "multiple">;
     /** Check if a key is selected. */
     isSelected(key: Key): boolean;
     /** Whether the combobox is disabled. */

package/dist/combobox/index.d.ts

@@ -1,4 +1,4 @@
 /**
  * ComboBox state management for Solid Stately.
  */
-export { createComboBoxState, defaultContainsFilter, type ComboBoxState, type ComboBoxStateProps, type FilterFn, type MenuTriggerAction, type FocusStrategy, } from './createComboBoxState';
+export { createComboBoxState, defaultContainsFilter, type ComboBoxState, type ComboBoxStateProps, type FilterFn, type MenuTriggerAction, type FocusStrategy, } from "./createComboBoxState";

package/dist/data/createAsyncList.d.ts

@@ -0,0 +1,111 @@
+/**
+ * createAsyncList - SolidJS port of React Spectrum's useAsyncList
+ *
+ * Manages state for an immutable async loaded list data structure, and provides
+ * convenience methods to update the data over time. Manages loading and error
+ * states, pagination, and sorting.
+ */
+export type Key = string | number;
+export type Selection = "all" | Set<Key>;
+export type LoadingState = "idle" | "loading" | "loadingMore" | "sorting" | "filtering" | "error";
+export interface SortDescriptor {
+    /** The key of the column to sort by. */
+    column?: Key;
+    /** The direction to sort by. */
+    direction?: "ascending" | "descending";
+}
+export interface AsyncListLoadOptions<T, C> {
+    /** The items currently in the list. */
+    items: T[];
+    /** The keys of the currently selected items in the list. */
+    selectedKeys: Selection;
+    /** The current sort descriptor for the list. */
+    sortDescriptor?: SortDescriptor;
+    /** An abort signal used to notify the load function that the request has been aborted. */
+    signal: AbortSignal;
+    /** The pagination cursor returned from the last page load. */
+    cursor?: C;
+    /** The current filter text used to perform server side filtering. */
+    filterText?: string;
+    /** The current loading state of the list. */
+    loadingState?: LoadingState;
+}
+export interface AsyncListStateUpdate<T, C> {
+    /** The new items to append to the list. */
+    items: Iterable<T>;
+    /** The keys to add to the selection. */
+    selectedKeys?: Iterable<Key>;
+    /** The sort descriptor to set. */
+    sortDescriptor?: SortDescriptor;
+    /** The pagination cursor to be used for the next page load. */
+    cursor?: C;
+    /** The updated filter text for the list. */
+    filterText?: string;
+}
+export type AsyncListLoadFunction<T, C> = (state: AsyncListLoadOptions<T, C>) => AsyncListStateUpdate<T, C> | Promise<AsyncListStateUpdate<T, C>>;
+export interface AsyncListOptions<T, C> {
+    /** The keys for the initially selected items. */
+    initialSelectedKeys?: "all" | Iterable<Key>;
+    /** The initial sort descriptor. */
+    initialSortDescriptor?: SortDescriptor;
+    /** The initial filter text. */
+    initialFilterText?: string;
+    /** A function that returns a unique key for an item object. */
+    getKey?: (item: T) => Key;
+    /** A function that loads the data for the items in the list. */
+    load: AsyncListLoadFunction<T, C>;
+    /** An optional function that performs sorting. */
+    sort?: AsyncListLoadFunction<T, C>;
+}
+export interface AsyncListData<T> {
+    /** The items in the list. */
+    readonly items: T[];
+    /** The keys of the currently selected items in the list. */
+    readonly selectedKeys: Selection;
+    /** The current sort descriptor for the list. */
+    readonly sortDescriptor: SortDescriptor | undefined;
+    /** Whether data is currently being loaded. */
+    readonly isLoading: boolean;
+    /** If loading data failed, then this contains the error that occurred. */
+    readonly error: Error | undefined;
+    /** The current filter text. */
+    readonly filterText: string;
+    /** The current loading state for the list. */
+    readonly loadingState: LoadingState;
+    /** Reloads the data in the list. */
+    reload(): void;
+    /** Loads the next page of data in the list. */
+    loadMore(): void;
+    /** Triggers sorting for the list. */
+    sort(descriptor: SortDescriptor): void;
+    /** Sets the selected keys. */
+    setSelectedKeys(keys: Selection): void;
+    /** Sets the filter text. */
+    setFilterText(filterText: string): void;
+    /** Gets an item from the list by key. */
+    getItem(key: Key): T | undefined;
+    /** Inserts items into the list at the given index. */
+    insert(index: number, ...values: T[]): void;
+    /** Inserts items before a given key. */
+    insertBefore(key: Key, ...values: T[]): void;
+    /** Inserts items after a given key. */
+    insertAfter(key: Key, ...values: T[]): void;
+    /** Appends items to the list. */
+    append(...values: T[]): void;
+    /** Prepends items to the list. */
+    prepend(...values: T[]): void;
+    /** Removes items from the list by their keys. */
+    remove(...keys: Key[]): void;
+    /** Removes all items from the list that are currently in the set of selected items. */
+    removeSelectedItems(): void;
+    /** Moves an item within the list. */
+    move(key: Key, toIndex: number): void;
+    /** Updates an item in the list. */
+    update(key: Key, newValue: T): void;
+}
+/**
+ * Manages state for an immutable async loaded list data structure, and provides
+ * convenience methods to update the data over time. Manages loading and error
+ * states, pagination, and sorting.
+ */
+export declare function createAsyncList<T, C = string>(options: AsyncListOptions<T, C>): AsyncListData<T>;

package/dist/data/createListData.d.ts

@@ -0,0 +1,65 @@
+/**
+ * createListData - SolidJS port of React Spectrum's useListData
+ *
+ * Manages state for an immutable list data structure, and provides
+ * convenience methods to update the data over time.
+ */
+export type Key = string | number;
+export type Selection = "all" | Set<Key>;
+export interface ListOptions<T> {
+    /** Initial items in the list. */
+    initialItems?: T[];
+    /** The keys for the initially selected items. */
+    initialSelectedKeys?: "all" | Iterable<Key>;
+    /** The initial text to filter the list by. */
+    initialFilterText?: string;
+    /** A function that returns a unique key for an item object. */
+    getKey?: (item: T) => Key;
+    /** A function that returns whether an item matches the current filter text. */
+    filter?: (item: T, filterText: string) => boolean;
+}
+export interface ListData<T> {
+    /** The items in the list. */
+    readonly items: T[];
+    /** The keys of the currently selected items in the list. */
+    readonly selectedKeys: Selection;
+    /** The current filter text. */
+    readonly filterText: string;
+    /** Sets the selected keys. */
+    setSelectedKeys(keys: Selection): void;
+    /** Adds the given keys to the current selected keys. */
+    addKeysToSelection(keys: Selection): void;
+    /** Removes the given keys from the current selected keys. */
+    removeKeysFromSelection(keys: Selection): void;
+    /** Sets the filter text. */
+    setFilterText(filterText: string): void;
+    /** Gets an item from the list by key. */
+    getItem(key: Key): T | undefined;
+    /** Inserts items into the list at the given index. */
+    insert(index: number, ...values: T[]): void;
+    /** Inserts items into the list before the item at the given key. */
+    insertBefore(key: Key, ...values: T[]): void;
+    /** Inserts items into the list after the item at the given key. */
+    insertAfter(key: Key, ...values: T[]): void;
+    /** Appends items to the list. */
+    append(...values: T[]): void;
+    /** Prepends items to the list. */
+    prepend(...values: T[]): void;
+    /** Removes items from the list by their keys. */
+    remove(...keys: Key[]): void;
+    /** Removes all items from the list that are currently in the set of selected items. */
+    removeSelectedItems(): void;
+    /** Moves an item within the list. */
+    move(key: Key, toIndex: number): void;
+    /** Moves one or more items before a given key. */
+    moveBefore(key: Key, keys: Iterable<Key>): void;
+    /** Moves one or more items after a given key. */
+    moveAfter(key: Key, keys: Iterable<Key>): void;
+    /** Updates an item in the list. */
+    update(key: Key, newValue: T | ((prev: T) => T)): void;
+}
+/**
+ * Manages state for an immutable list data structure, and provides
+ * convenience methods to update the data over time.
+ */
+export declare function createListData<T>(options: ListOptions<T>): ListData<T>;

package/dist/data/createTreeData.d.ts

@@ -0,0 +1,65 @@
+/**
+ * createTreeData - SolidJS port of React Spectrum's useTreeData
+ *
+ * Manages state for an immutable tree data structure, and provides
+ * convenience methods to update the data over time.
+ */
+export type Key = string | number;
+export type Selection = "all" | Set<Key>;
+export interface TreeNode<T> {
+    /** A unique key for the tree node. */
+    key: Key;
+    /** The key of the parent node. */
+    parentKey: Key | null;
+    /** The value object for the tree node. */
+    value: T;
+    /** The children of this node. */
+    children: TreeNode<T>[] | null;
+}
+export interface TreeOptions<T> {
+    /** Initial items in the tree. */
+    initialItems?: T[];
+    /** The keys for the initially selected items. */
+    initialSelectedKeys?: "all" | Iterable<Key>;
+    /** A function that returns a unique key for an item object. */
+    getKey?: (item: T) => Key;
+    /** A function that returns the children of an item object. */
+    getChildren?: (item: T) => T[];
+}
+export interface TreeData<T> {
+    /** The root items in the tree. */
+    readonly items: TreeNode<T>[];
+    /** The keys of the currently selected items in the tree. */
+    readonly selectedKeys: Selection;
+    /** Sets the selected keys. */
+    setSelectedKeys(keys: Selection): void;
+    /** Gets an item from the tree by key. */
+    getItem(key: Key): TreeNode<T> | undefined;
+    /** Inserts items into the tree. */
+    insert(parentKey: Key | null, index: number, ...values: T[]): void;
+    /** Inserts items before a given key. */
+    insertBefore(key: Key, ...values: T[]): void;
+    /** Inserts items after a given key. */
+    insertAfter(key: Key, ...values: T[]): void;
+    /** Appends items to a parent node. */
+    append(parentKey: Key | null, ...values: T[]): void;
+    /** Prepends items to a parent node. */
+    prepend(parentKey: Key | null, ...values: T[]): void;
+    /** Removes items from the tree by their keys. */
+    remove(...keys: Key[]): void;
+    /** Removes all items from the tree that are currently in the set of selected items. */
+    removeSelectedItems(): void;
+    /** Moves an item to a new parent. */
+    move(key: Key, toParentKey: Key | null, index: number): void;
+    /** Moves items before a given key. */
+    moveBefore(key: Key, keys: Iterable<Key>): void;
+    /** Moves items after a given key. */
+    moveAfter(key: Key, keys: Iterable<Key>): void;
+    /** Updates an item in the tree. */
+    update(key: Key, newValue: T): void;
+}
+/**
+ * Manages state for an immutable tree data structure, and provides
+ * convenience methods to update the data over time.
+ */
+export declare function createTreeData<T>(options: TreeOptions<T>): TreeData<T>;

package/dist/data/index.d.ts

@@ -0,0 +1,3 @@
+export { createListData, type ListOptions, type ListData, type Key as ListDataKey, type Selection as ListDataSelection, } from "./createListData";
+export { createTreeData, type TreeOptions, type TreeData, type TreeNode as TreeDataNode, } from "./createTreeData";
+export { createAsyncList, type AsyncListOptions, type AsyncListData, type AsyncListLoadFunction, type AsyncListLoadOptions, type AsyncListStateUpdate, type SortDescriptor, type LoadingState, } from "./createAsyncList";

package/dist/datepicker/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Datepicker compatibility surface.
+ *
+ * This is a module-compat shim that maps React Stately datepicker hook names
+ * to existing Solid stately primitives.
+ */
+export { createDateFieldState, createTimeFieldState, createRangeCalendarState, createDatePickerState, type DateFieldStateProps as DateFieldStateOptions, type DateFieldState, type DateSegment, type DateSegmentType as SegmentType, type TimeFieldStateProps as TimeFieldStateOptions, type TimeFieldState, type TimeSegment, type TimeSegmentType, type RangeCalendarStateProps as DateRangePickerStateOptions, type RangeCalendarState as DateRangePickerState, type DatePickerState, type DatePickerStateOptions, } from "../calendar";
+export { createDateFieldState as useDateFieldState, createTimeFieldState as useTimeFieldState, createRangeCalendarState as useDateRangePickerState, createDatePickerState as useDatePickerState, } from "../calendar";

package/dist/disclosure/createDisclosureState.d.ts

@@ -2,8 +2,8 @@
  * Disclosure state management for SolidJS
  * Based on @react-stately/disclosure useDisclosureState and useDisclosureGroupState
  */
-import { type Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
+import { type Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
 export interface DisclosureStateProps {
     /** Whether the disclosure is expanded (controlled). */
     isExpanded?: boolean;

package/dist/disclosure/index.d.ts

@@ -1 +1 @@
-export { createDisclosureState, createDisclosureGroupState, type DisclosureStateProps, type DisclosureState, type DisclosureGroupStateProps, type DisclosureGroupState, type Key, } from './createDisclosureState';
+export { createDisclosureState, createDisclosureGroupState, type DisclosureStateProps, type DisclosureState, type DisclosureGroupStateProps, type DisclosureGroupState, type Key, } from "./createDisclosureState";

package/dist/dnd/createDragState.d.ts

@@ -3,8 +3,8 @@
  *
  * Provides reactive state for drag operations.
  */
-import { type Accessor } from 'solid-js';
-import type { DragItem, DragStartEvent, DragMoveEvent, DragEndEvent, DropOperation, DragPreviewRenderer } from './types';
+import { type Accessor } from "solid-js";
+import type { DragItem, DragStartEvent, DragMoveEvent, DragEndEvent, DropOperation, DragPreviewRenderer } from "./types";
 export interface DragStateOptions {
     /** A function that returns the items being dragged. */
     getItems: () => DragItem[];

package/dist/dnd/createDraggableCollectionState.d.ts

@@ -3,8 +3,8 @@
  *
  * Provides reactive state for dragging items from a collection.
  */
-import { type Accessor } from 'solid-js';
-import type { DragItem, DraggableCollectionStartEvent, DraggableCollectionMoveEvent, DraggableCollectionEndEvent, DropOperation, DragPreviewRenderer } from './types';
+import { type Accessor } from "solid-js";
+import type { DragItem, DraggableCollectionStartEvent, DraggableCollectionMoveEvent, DraggableCollectionEndEvent, DropOperation, DragPreviewRenderer } from "./types";
 export interface DraggableCollectionStateOptions<T = object> {
     /** A function that returns the items being dragged. */
     getItems: (keys: Set<string | number>) => DragItem[];

package/dist/dnd/createDropState.d.ts

@@ -3,8 +3,8 @@
  *
  * Provides reactive state for drop target operations.
  */
-import { type Accessor } from 'solid-js';
-import type { DropItem, DropEnterEvent, DropMoveEvent, DropExitEvent, DropActivateEvent, DropEvent, DropOperation, DragTypes } from './types';
+import { type Accessor } from "solid-js";
+import type { DropItem, DropEnterEvent, DropMoveEvent, DropExitEvent, DropActivateEvent, DropEvent, DropOperation, DragTypes } from "./types";
 export interface DropStateOptions {
     /**
      * A function returning the drop operation to be performed.

package/dist/dnd/createDroppableCollectionState.d.ts

@@ -3,14 +3,14 @@
  *
  * Provides reactive state for accepting drops onto a collection.
  */
-import { type Accessor } from 'solid-js';
-import type { DropItem, DropTarget, DropOperation, DragTypes, DroppableCollectionEnterEvent, DroppableCollectionActivateEvent, DroppableCollectionExitEvent, DroppableCollectionDropEvent, DroppableCollectionInsertDropEvent, DroppableCollectionRootDropEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, ItemDropTarget } from './types';
+import { type Accessor } from "solid-js";
+import type { DropItem, DropTarget, DropOperation, DragTypes, DroppableCollectionEnterEvent, DroppableCollectionActivateEvent, DroppableCollectionExitEvent, DroppableCollectionDropEvent, DroppableCollectionInsertDropEvent, DroppableCollectionRootDropEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, ItemDropTarget } from "./types";
 export interface DroppableCollectionStateOptions {
     /**
      * The drag types that the droppable collection accepts.
      * @default 'all'
      */
-    acceptedDragTypes?: 'all' | Array<string | symbol>;
+    acceptedDragTypes?: "all" | Array<string | symbol>;
     /**
      * A function returning the drop operation to be performed.
      */

package/dist/dnd/index.d.ts

@@ -3,8 +3,8 @@
  *
  * Exports for DnD functionality.
  */
-export type { DropOperation, DragItem, DragDropEvent, DragStartEvent, DragMoveEvent, DragEndEvent, DropEnterEvent, DropMoveEvent, DropActivateEvent, DropExitEvent, TextDropItem, FileDropItem, DirectoryDropItem, DropItem, DropEvent, DropPosition, RootDropTarget, ItemDropTarget, DropTarget, DroppableCollectionEnterEvent, DroppableCollectionMoveEvent, DroppableCollectionActivateEvent, DroppableCollectionExitEvent, DroppableCollectionDropEvent, DroppableCollectionInsertDropEvent, DroppableCollectionRootDropEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, DragTypes, DropTargetDelegate, DraggableCollectionStartEvent, DraggableCollectionMoveEvent, DraggableCollectionEndEvent, DragPreviewRenderer, DroppableCollectionUtilityOptions, DroppableCollectionBaseProps, DroppableCollectionProps, DraggableCollectionProps, } from './types';
-export { createDragState, type DragStateOptions, type DragState, } from './createDragState';
-export { createDropState, type DropStateOptions, type DropState, } from './createDropState';
-export { createDraggableCollectionState, type DraggableCollectionStateOptions, type DraggableCollectionState, } from './createDraggableCollectionState';
-export { createDroppableCollectionState, DIRECTORY_DRAG_TYPE, type DroppableCollectionStateOptions, type DroppableCollectionState, } from './createDroppableCollectionState';
+export type { DropOperation, DragItem, DragDropEvent, DragStartEvent, DragMoveEvent, DragEndEvent, DropEnterEvent, DropMoveEvent, DropActivateEvent, DropExitEvent, TextDropItem, FileDropItem, DirectoryDropItem, DropItem, DropEvent, DropPosition, RootDropTarget, ItemDropTarget, DropTarget, DroppableCollectionEnterEvent, DroppableCollectionMoveEvent, DroppableCollectionActivateEvent, DroppableCollectionExitEvent, DroppableCollectionDropEvent, DroppableCollectionInsertDropEvent, DroppableCollectionRootDropEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, DragTypes, DropTargetDelegate, DraggableCollectionStartEvent, DraggableCollectionMoveEvent, DraggableCollectionEndEvent, DragPreviewRenderer, DroppableCollectionUtilityOptions, DroppableCollectionBaseProps, DroppableCollectionProps, DraggableCollectionProps, } from "./types";
+export { createDragState, type DragStateOptions, type DragState } from "./createDragState";
+export { createDropState, type DropStateOptions, type DropState } from "./createDropState";
+export { createDraggableCollectionState, type DraggableCollectionStateOptions, type DraggableCollectionState, } from "./createDraggableCollectionState";
+export { createDroppableCollectionState, DIRECTORY_DRAG_TYPE, type DroppableCollectionStateOptions, type DroppableCollectionState, } from "./createDroppableCollectionState";

package/dist/dnd/types.d.ts

@@ -4,7 +4,7 @@
  * Core types for drag and drop operations, matching React Aria's DnD API.
  */
 /** The type of drop operation to perform. */
-export type DropOperation = 'copy' | 'link' | 'move' | 'cancel';
+export type DropOperation = "copy" | "link" | "move" | "cancel";
 /** Drag item data as key-value pairs where keys are MIME types or custom types. */
 export interface DragItem {
     [type: string]: string;
@@ -19,44 +19,44 @@ export interface DragDropEvent {
 /** Event fired when a drag operation starts. */
 export interface DragStartEvent extends DragDropEvent {
     /** The event type. */
-    type: 'dragstart';
+    type: "dragstart";
 }
 /** Event fired as a drag moves. */
 export interface DragMoveEvent extends DragDropEvent {
     /** The event type. */
-    type: 'dragmove';
+    type: "dragmove";
 }
 /** Event fired when a drag operation ends. */
 export interface DragEndEvent extends DragDropEvent {
     /** The event type. */
-    type: 'dragend';
+    type: "dragend";
     /** The drop operation that occurred. */
     dropOperation: DropOperation;
 }
 /** Event fired when a drag enters a drop target. */
 export interface DropEnterEvent extends DragDropEvent {
     /** The event type. */
-    type: 'dropenter';
+    type: "dropenter";
 }
 /** Event fired as a drag moves within a drop target. */
 export interface DropMoveEvent extends DragDropEvent {
     /** The event type. */
-    type: 'dropmove';
+    type: "dropmove";
 }
 /** Event fired when a drag is held over a drop target. */
 export interface DropActivateEvent extends DragDropEvent {
     /** The event type. */
-    type: 'dropactivate';
+    type: "dropactivate";
 }
 /** Event fired when a drag exits a drop target. */
 export interface DropExitEvent extends DragDropEvent {
     /** The event type. */
-    type: 'dropexit';
+    type: "dropexit";
 }
 /** A text item in a drop operation. */
 export interface TextDropItem {
     /** The item kind. */
-    kind: 'text';
+    kind: "text";
     /** The drag types available for this item. */
     types: Set<string>;
     /** Returns the data for the given type as a string. */
@@ -65,7 +65,7 @@ export interface TextDropItem {
 /** A file item in a drop operation. */
 export interface FileDropItem {
     /** The item kind. */
-    kind: 'file';
+    kind: "file";
     /** The file type (usually a mime type). */
     type: string;
     /** The file name. */
@@ -78,7 +78,7 @@ export interface FileDropItem {
 /** A directory item in a drop operation. */
 export interface DirectoryDropItem {
     /** The item kind. */
-    kind: 'directory';
+    kind: "directory";
     /** The directory name. */
     name: string;
     /** Returns the entries contained within the directory. */
@@ -89,23 +89,23 @@ export type DropItem = TextDropItem | FileDropItem | DirectoryDropItem;
 /** Event fired when items are dropped. */
 export interface DropEvent extends DragDropEvent {
     /** The event type. */
-    type: 'drop';
+    type: "drop";
     /** The drop operation that should occur. */
     dropOperation: DropOperation;
     /** The dropped items. */
     items: DropItem[];
 }
 /** Position relative to an item for drop operations. */
-export type DropPosition = 'on' | 'before' | 'after';
+export type DropPosition = "on" | "before" | "after";
 /** Drop target representing the root of a collection. */
 export interface RootDropTarget {
     /** The drop target type. */
-    type: 'root';
+    type: "root";
 }
 /** Drop target representing an item in a collection. */
 export interface ItemDropTarget {
     /** The drop target type. */
-    type: 'item';
+    type: "item";
     /** The item key. */
     key: string | number;
     /** The drop position relative to the item. */
@@ -214,7 +214,7 @@ export interface DroppableCollectionUtilityOptions {
      * The drag types that the droppable collection accepts.
      * @default 'all'
      */
-    acceptedDragTypes?: 'all' | Array<string | symbol>;
+    acceptedDragTypes?: "all" | Array<string | symbol>;
     /** Handler that is called when external items are dropped "between" items. */
     onInsert?: (e: DroppableCollectionInsertDropEvent) => void;
     /** Handler that is called when external items are dropped on the collection's root. */

package/dist/form/createFormValidationState.d.ts

@@ -6,7 +6,7 @@
  *
  * Port of react-stately's useFormValidationState.
  */
-import { type Accessor } from 'solid-js';
+import { type Accessor } from "solid-js";
 /** Standard HTML ValidityState interface. */
 export interface ValidityState {
     badInput: boolean;
@@ -35,12 +35,12 @@ export type ValidationErrors = Record<string, string | string[]>;
 /** Validation function that returns error messages or true/false. */
 export type ValidationFunction<T> = (value: T) => boolean | string | string[] | null | undefined;
 /** Validation behavior mode. */
-export type ValidationBehavior = 'aria' | 'native';
+export type ValidationBehavior = "aria" | "native";
 export interface FormValidationProps<T> {
     /** Whether the value is invalid (controlled). */
     isInvalid?: boolean;
     /** @deprecated Use isInvalid instead. */
-    validationState?: 'valid' | 'invalid';
+    validationState?: "valid" | "invalid";
     /** Custom validation function. */
     validate?: ValidationFunction<T>;
     /** Validation behavior: 'aria' for realtime, 'native' for on submit. */

package/dist/form/index.d.ts

@@ -1 +1 @@
-export { createFormValidationState, mergeValidation, FormValidationContext, privateValidationStateProp, VALID_VALIDITY_STATE, DEFAULT_VALIDATION_RESULT, type FormValidationState, type FormValidationProps, type ValidationResult, type ValidationErrors, type ValidationFunction, type ValidationBehavior, type ValidityState, } from './createFormValidationState';
+export { createFormValidationState, mergeValidation, FormValidationContext, privateValidationStateProp, VALID_VALIDITY_STATE, DEFAULT_VALIDATION_RESULT, type FormValidationState, type FormValidationProps, type ValidationResult, type ValidationErrors, type ValidationFunction, type ValidationBehavior, type ValidityState, } from "./createFormValidationState";

package/dist/grid/createGridState.d.ts

@@ -2,8 +2,8 @@
  * Grid state management for Table and GridList components.
  * Based on @react-stately/grid/useGridState.
  */
-import { type Accessor } from 'solid-js';
-import type { GridState, GridStateOptions, GridCollection } from './types';
+import { type Accessor } from "solid-js";
+import type { GridState, GridStateOptions, GridCollection } from "./types";
 /**
  * Creates state management for a grid component.
  * Handles row selection, focus management, and keyboard navigation state.

package/dist/grid/index.d.ts

@@ -2,5 +2,5 @@
  * Grid state management module.
  * Provides state hooks for Table and GridList components.
  */
-export { createGridState } from './createGridState';
-export type { GridState, GridStateOptions, GridCollection, GridNode, GridNodeType, } from './types';
+export { createGridState } from "./createGridState";
+export type { GridState, GridStateOptions, GridCollection, GridNode, GridNodeType } from "./types";