@proyecto-viviana/solid-stately 0.3.0 → 0.4.1

package/dist/select/createSelectState.d.ts

@@ -6,6 +6,7 @@ import { type Accessor } from "solid-js";
 import { type MaybeAccessor } from "../utils";
 import type { Key, CollectionNode, Collection } from "../collections/types";
 import type { SelectionMode, Selection } from "../collections/types";
+import type { SelectionManager } from "../selection/SelectionManager";
 export interface SelectStateProps<T = unknown> {
     /** The items to display in the select. */
     items: T[];
@@ -45,6 +46,11 @@ export interface SelectStateProps<T = unknown> {
 export interface SelectState<T = unknown> {
     /** The collection of items. */
     readonly collection: Accessor<Collection<T>>;
+    /**
+     * The collection-aware selection manager. Mirrors upstream `useSelectState`,
+     * which spreads the underlying `useListState` (including its selection manager).
+     */
+    readonly selectionManager: SelectionManager<T>;
     /** Whether the select dropdown is open. */
     readonly isOpen: Accessor<boolean>;
     /** Open the select dropdown. */

package/dist/selection/Selection.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A Selection is a special Set containing Keys, which also has an anchor
+ * and current selected key for use when range selecting.
+ *
+ * Based on @react-stately/selection.
+ */
+import type { Key } from "../collections/types";
+/**
+ * A Selection is a special Set containing Keys, which also has an anchor
+ * and current selected key for use when range selecting.
+ */
+export declare class Selection extends Set<Key> {
+    anchorKey: Key | null;
+    currentKey: Key | null;
+    constructor(keys?: Iterable<Key> | Selection, anchorKey?: Key | null, currentKey?: Key | null);
+}

package/dist/selection/SelectionManager.d.ts

@@ -0,0 +1,119 @@
+/**
+ * An interface for reading and updating multiple selection state.
+ *
+ * The upper of the two selection layers ported from upstream
+ * (`@react-stately/selection`'s `SelectionManager`): the collection-aware
+ * operations built on top of the raw {@link MultipleSelectionState}.
+ *
+ * React → Solid adaptations, all faithful to upstream's observable contract:
+ *  - Upstream re-instantiates `SelectionManager` every render to capture a
+ *    fresh `collection`. Here the manager is long-lived, so it captures a
+ *    reactive `collection` accessor and reads it live via `get collection()`.
+ *  - Upstream caches `_isSelectAll` for the lifetime of one render. A
+ *    long-lived manager would let that cache go stale, so it is dropped and
+ *    `isSelectAll` recomputes (it is consulted rarely — only by select-all UI).
+ *  - Our `CollectionNode` has no `'cell'` type (grids/trees use a separate
+ *    state engine), so the cell-selection branches are omitted.
+ *
+ * Based on @react-stately/selection.
+ */
+import type { SelectionPressEvent } from "../collections/createSelectionState";
+import type { Collection, DisabledBehavior, FocusStrategy, Key, Selection as SelectionValue, SelectionBehavior, SelectionMode } from "../collections/types";
+import type { MultipleSelectionState } from "./createMultipleSelectionState";
+/** A delegate that can resolve a key range without walking the collection (e.g. a virtualized layout). */
+export interface LayoutDelegate {
+    getKeyRange?(from: Key, to: Key): Key[];
+}
+export interface SelectionManagerOptions<T = unknown> {
+    layoutDelegate?: LayoutDelegate;
+    /**
+     * The full (unfiltered) collection, used when materializing the 'all'
+     * selection so that filtered-out items (e.g. by Autocomplete) are still
+     * included.
+     */
+    fullCollection?: Collection<T>;
+}
+/**
+ * An interface for reading and updating multiple selection state.
+ */
+export declare class SelectionManager<T = unknown> {
+    private collectionAccessor;
+    private state;
+    private layoutDelegate;
+    private fullCollection;
+    constructor(collection: () => Collection<T>, state: MultipleSelectionState, options?: SelectionManagerOptions<T>);
+    /** The collection the manager operates over (read live so it stays reactive). */
+    get collection(): Collection<T>;
+    /** The type of selection that is allowed in the collection. */
+    get selectionMode(): SelectionMode;
+    /** Whether the collection allows empty selection. */
+    get disallowEmptySelection(): boolean;
+    /** The selection behavior for the collection. */
+    get selectionBehavior(): SelectionBehavior;
+    /** Sets the selection behavior for the collection. */
+    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
+    /** Whether the collection is currently focused. */
+    get isFocused(): boolean;
+    /** Sets whether the collection is focused. */
+    setFocused(isFocused: boolean): void;
+    /** The current focused key in the collection. */
+    get focusedKey(): Key | null;
+    /** Whether the first or last child of the focused key should receive focus. */
+    get childFocusStrategy(): FocusStrategy | null;
+    /** Sets the focused key. */
+    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy): void;
+    /** The currently selected keys in the collection (materialized — 'all' is expanded). */
+    get selectedKeys(): Set<Key>;
+    /** The raw selection value for the collection. Either 'all' for select all, or a set of keys. */
+    get rawSelection(): SelectionValue;
+    /** Last selection payload emitted through onSelectionChange. @internal */
+    get lastSelectionEvent(): SelectionValue | null;
+    /** Re-emits a selection payload without recomputing selection. @internal */
+    emitDuplicateSelectionEvent(keys?: SelectionValue | null): void;
+    /** Returns whether a key is selected. */
+    isSelected(key: Key): boolean;
+    /** Whether the selection is empty. */
+    get isEmpty(): boolean;
+    /** Whether all items in the collection are selected. */
+    get isSelectAll(): boolean;
+    get firstSelectedKey(): Key | null;
+    get lastSelectedKey(): Key | null;
+    get disabledKeys(): Set<Key>;
+    get disabledBehavior(): DisabledBehavior;
+    /** Extends the selection to the given key. */
+    extendSelection(toKey: Key): void;
+    private getKeyRange;
+    private getKeyRangeInternal;
+    private getKey;
+    /** Toggles whether the given key is selected. */
+    toggleSelection(key: Key): void;
+    /** Replaces the selection with only the given key. */
+    replaceSelection(key: Key): void;
+    /** Replaces the selection with the given keys. */
+    setSelectedKeys(keys: Iterable<Key>): void;
+    private getSelectAllKeys;
+    /** Selects all items in the collection. */
+    selectAll(): void;
+    /** Removes all keys from the selection. */
+    clearSelection(): void;
+    /** Toggles between select all and an empty selection. */
+    toggleSelectAll(): void;
+    select(key: Key, e?: SelectionPressEvent): void;
+    /** Returns whether the current selection is equal to the given selection. */
+    isSelectionEqual(selection: Set<Key>): boolean;
+    canSelectItem(key: Key): boolean;
+    private canSelectItemIn;
+    isDisabled(key: Key): boolean;
+    isLink(key: Key): boolean;
+    getItemProps(key: Key): Record<string, unknown> | undefined;
+    withCollection(collection: Collection<T>): SelectionManager<T>;
+    /**
+     * Like {@link withCollection}, but the collection is supplied as a live
+     * accessor so the returned manager stays reactive as the collection recomputes
+     * (e.g. an Autocomplete filter narrowing the list as the user types). The
+     * shared underlying selection/focus state is preserved, and the original
+     * (unfiltered) collection is retained as `fullCollection` so a select-all
+     * still materializes the filtered-out keys.
+     */
+    withCollectionAccessor(collection: () => Collection<T>): SelectionManager<T>;
+}

package/dist/selection/createMultipleSelectionState.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Raw multiple-selection + focus state for a collection.
+ *
+ * The lower of the two selection layers ported from upstream
+ * (`@react-stately/selection`'s `useMultipleSelectionState`): it owns the
+ * selected keys, focus, selection behavior, and disabled keys, but is NOT
+ * collection-aware. The collection-aware operations (toggle, extend, select
+ * all, range, etc.) live in {@link SelectionManager}, which is built on top of
+ * this state.
+ *
+ * Based on @react-stately/selection.
+ */
+import { type Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
+import type { SelectionStateProps } from "../collections/createSelectionState";
+import type { DisabledBehavior, FocusStrategy, Key, Selection, SelectionBehavior, SelectionMode } from "../collections/types";
+/**
+ * The raw state consumed by {@link SelectionManager}. Mirrors upstream's
+ * `MultipleSelectionState`: property reads (not Solid accessors) so the manager
+ * can read `state.selectionMode` etc. exactly as upstream does — the getters
+ * read the underlying signals, so reads inside reactive scopes still track.
+ */
+export interface MultipleSelectionState {
+    /** The type of selection that is allowed in the collection. */
+    readonly selectionMode: SelectionMode;
+    /** The selection behavior for the collection. */
+    readonly selectionBehavior: SelectionBehavior;
+    /** Sets the selection behavior for the collection. */
+    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
+    /** Whether the collection allows empty selection. */
+    readonly disallowEmptySelection: boolean;
+    /** Whether the collection is currently focused. */
+    readonly isFocused: boolean;
+    /** Sets whether the collection is focused. */
+    setFocused(isFocused: boolean): void;
+    /** The current focused key in the collection. */
+    readonly focusedKey: Key | null;
+    /** Whether the first or last child of the focused key should receive focus. */
+    readonly childFocusStrategy: FocusStrategy | null;
+    /** Sets the focused key, and optionally, whether the first or last child of that key should receive focus. */
+    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy): void;
+    /** The currently selected keys in the collection. */
+    readonly selectedKeys: Selection;
+    /** The last selection payload emitted through onSelectionChange. @internal */
+    readonly lastSelectionEvent: Selection | null;
+    /** Sets the selected keys in the collection. */
+    setSelectedKeys(keys: Selection): void;
+    /** Re-emits a selection payload without recomputing or mutating selection. @internal */
+    emitDuplicateSelectionEvent(keys?: Selection): void;
+    /** The currently disabled keys in the collection. */
+    readonly disabledKeys: Set<Key>;
+    /** Whether `disabledKeys` applies to all interactions, or only selection. */
+    readonly disabledBehavior: DisabledBehavior;
+}
+/**
+ * Manages raw state for multiple selection and focus in a collection.
+ */
+export declare function createMultipleSelectionState(props?: MaybeAccessor<SelectionStateProps>): MultipleSelectionState;
+export type { Accessor };

package/dist/selection/index.d.ts

@@ -5,6 +5,7 @@
  * delegating to the existing Solid collection selection primitives.
  */
 export { createSelectionState, type SelectionStateProps, type SelectionState, } from "../collections/createSelectionState";
+export { SelectionManager, type SelectionManagerOptions, type LayoutDelegate, } from "./SelectionManager";
 export type { Key, Selection, SelectionMode, SelectionBehavior, DisabledBehavior, FocusStrategy, } from "../collections/types";
 export type MultipleSelectionStateProps = import("../collections/createSelectionState").SelectionStateProps;
 export type MultipleSelectionState = import("../collections/createSelectionState").SelectionState;

package/dist/table/TableCollection.d.ts

@@ -1,6 +1,12 @@
 /**
  * TableCollection - A collection class for table data.
  * Based on @react-stately/table/TableCollection.
+ *
+ * Supports a plain (flat) table and, when an `expandedKeys` option is supplied, a
+ * tree grid: `childRows` are walked recursively, each parent row keeps its full
+ * structure (cells followed by every child row), and only rows whose ancestors are
+ * all expanded are flattened into the navigable body. Mirrors the structure produced
+ * by `@react-stately/table`'s `generateTreeGridCollection`.
  */
 import type { Key } from "../collections/types";
 import type { GridNode } from "../grid/types";
@@ -17,12 +23,30 @@ export declare class TableCollection<T = unknown> implements ITableCollection<T>
     private _keyMap;
     private _rowHeaderColumnKeys;
     private _size;
+    /** Visible rows in DFS order. Drives size, navigation, iteration and the `rows` list. */
+    private _flattenedRows;
+    private _treeColumn;
+    private _userColumnCount;
     constructor(options: TableCollectionOptions<T>);
     private buildColumns;
     private buildColumnNode;
     private getDefaultRowHeaderColumnKeys;
+    /** Counts the leaf columns supplied by the user (excludes the selection column). */
+    private countLeafColumns;
     private buildHeaderRows;
+    /**
+     * Builds the cell nodes for one row. Does not register the cells in the key map;
+     * the caller registers cells once the owning row is known to be present.
+     */
+    private buildCells;
     private buildRows;
+    /**
+     * Builds the tree-grid rows: every row keeps its full structure (cells then all child
+     * rows, expanded or not) while only the rows whose ancestors are all expanded are
+     * registered in the key map and pushed into the flattened body. Mirrors
+     * `generateTreeGridCollection` upstream.
+     */
+    private buildTreeRows;
     private isRowDefinition;
     get size(): number;
     get rows(): GridNode<T>[];
@@ -33,6 +57,12 @@ export declare class TableCollection<T = unknown> implements ITableCollection<T>
     get rowCount(): number;
     get columnCount(): number;
     get rowHeaderColumnKeys(): Set<Key>;
+    /** The key of the column that renders the tree-grid affordance, or `null` for a flat table. */
+    get treeColumn(): Key | null;
+    /** The number of leaf columns provided by the user (excludes the selection column). */
+    get userColumnCount(): number;
+    /** The key map of all present nodes (visible rows, their cells, columns and the body). */
+    get keyMap(): Map<Key, GridNode<T>>;
     getKeys(): Iterable<Key>;
     getItem(key: Key): GridNode<T> | null;
     at(index: number): GridNode<T> | null;

package/dist/table/createTreeGridState.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Tree grid state management for expandable Table rows.
+ * Based on @react-stately/table/useTreeGridState (the `UNSTABLE_` tree-grid feature).
+ *
+ * Owns the expanded-keys signal (controlled or uncontrolled), rebuilds the table
+ * collection from it, and layers the expansion API on top of {@link createTableState}.
+ */
+import { type Accessor } from "solid-js";
+import { TableCollection } from "./TableCollection";
+import type { TreeGridState, TreeGridStateOptions } from "./types";
+/**
+ * Creates state management for a tree grid (a table with expandable rows). Handles the
+ * expanded rows in addition to the selection, sort and focus handled by the table state.
+ */
+export declare function createTreeGridState<T extends object, C extends TableCollection<T> = TableCollection<T>>(options: Accessor<TreeGridStateOptions<T, C>>): TreeGridState<T, C>;

package/dist/table/index.d.ts

@@ -3,7 +3,8 @@
  * Provides state hooks for Table components.
  */
 export { createTableState } from "./createTableState";
+export { createTreeGridState } from "./createTreeGridState";
 export { createTableColumnResizeState } from "./createTableColumnResizeState";
 export { TableCollection, createTableCollection } from "./TableCollection";
-export type { TableState, TableStateOptions, TableCollection as ITableCollection, SortDescriptor, SortDirection, Sortable, ColumnDefinition, RowDefinition, TableCollectionOptions, } from "./types";
+export type { TableState, TableStateOptions, TableCollection as ITableCollection, TreeGridState, TreeGridStateOptions, SortDescriptor, SortDirection, Sortable, ColumnDefinition, RowDefinition, TableCollectionOptions, } from "./types";
 export type { ColumnSize, ColumnResizeDefinition, TableColumnResizeStateProps, TableColumnResizeState, } from "./createTableColumnResizeState";

package/dist/table/types.d.ts

@@ -41,6 +41,8 @@ export interface TableCollection<T = unknown> extends GridCollection<T> {
     readonly head?: GridNode<T>;
     /** The node that makes up the body of the table. */
     readonly body: GridNode<T>;
+    /** The key of the column that renders the tree-grid expand/collapse affordance, if any. */
+    readonly treeColumn?: Key | null;
 }
 /**
  * State for a table component.
@@ -55,6 +57,51 @@ export interface TableState<T, C extends TableCollection<T> = TableCollection<T>
     readonly sortDescriptor: SortDescriptor | null;
     /** Sort by the given column and direction. */
     sort(columnKey: Key, direction?: SortDirection): void;
+    /**
+     * The set of expanded row keys for tree grids. A plain table reports an empty set.
+     */
+    readonly expandedKeys: "all" | Set<Key>;
+    /**
+     * The key of the column that renders the expand/collapse affordance, or `null` for a
+     * plain (non-tree) table.
+     */
+    readonly treeColumn: Key | null;
+    /** Toggles the expanded state of a row by its key (no-op for a plain table). */
+    toggleKey(key: Key): void;
+}
+/**
+ * State for a tree grid (expandable rows). Mirrors `@react-stately/table`'s
+ * `UNSTABLE_useTreeGridState` return value.
+ */
+export interface TreeGridState<T, C extends TableCollection<T> = TableCollection<T>> extends TableState<T, C> {
+    /** A set of keys for rows that are expanded. */
+    readonly expandedKeys: "all" | Set<Key>;
+    /** The key map containing nodes representing the collection's tree grid structure. */
+    readonly keyMap: Map<Key, GridNode<T>>;
+    /** The number of leaf columns provided by the user (excludes selection/drag columns). */
+    readonly userColumnCount: number;
+}
+/**
+ * Options for creating tree grid state. Mirrors `TreeGridStateProps` upstream; the
+ * expansion props keep the `UNSTABLE_` prefix while the feature is unstable.
+ */
+export interface TreeGridStateOptions<T, C extends TableCollection<T> = TableCollection<T>> extends Omit<TableStateOptions<T, C>, "collection"> {
+    /** Column definitions. */
+    columns: ColumnDefinition<T>[];
+    /** Row definitions (may contain `childRows` for nested rows). */
+    rows: RowDefinition<T>[];
+    /** Function to get the key from a data item. */
+    getKey?: (item: T) => Key;
+    /** Function to get the text value from a data item. */
+    getTextValue?: (item: T, column: ColumnDefinition<T>) => string;
+    /** Set of column keys that serve as row headers. */
+    rowHeaderColumnKeys?: Set<Key>;
+    /** The currently expanded keys in the collection (controlled). */
+    UNSTABLE_expandedKeys?: "all" | Iterable<Key>;
+    /** The initial expanded keys in the collection (uncontrolled). */
+    UNSTABLE_defaultExpandedKeys?: "all" | Iterable<Key>;
+    /** Handler that is called when rows are expanded or collapsed. */
+    UNSTABLE_onExpandedChange?: (keys: Set<Key>) => void;
 }
 /**
  * Options for creating table state.
@@ -64,6 +111,8 @@ export interface TableStateOptions<T, C extends TableCollection<T> = TableCollec
     collection: C;
     /** Keys of disabled rows. */
     disabledKeys?: Iterable<Key>;
+    /** Whether `disabledKeys` applies to all interactions, or only selection. @default "all" */
+    disabledBehavior?: "selection" | "all";
     /** Focus mode: 'row' or 'cell'. */
     focusMode?: "row" | "cell";
     /** Selection mode. */
@@ -135,4 +184,13 @@ export interface TableCollectionOptions<T = unknown> {
     showSelectionCheckboxes?: boolean;
     /** Set of column keys that serve as row headers. */
     rowHeaderColumnKeys?: Set<Key>;
+    /**
+     * The set of expanded row keys. Passing this (even an empty set) builds the collection
+     * in tree-grid mode: `childRows` are walked recursively, only rows whose ancestors are
+     * all expanded are flattened into the navigable body, and {@link TableCollection.treeColumn}
+     * resolves to a real column. Omit it for a plain (non-tree) table.
+     */
+    expandedKeys?: "all" | Set<Key>;
+    /** Explicit tree column key. Defaults to the first row-header column in tree-grid mode. */
+    treeColumn?: Key | null;
 }

package/dist/toast/createToastState.d.ts

@@ -27,11 +27,19 @@ export interface QueuedToast<T> {
     /** The timeout for the toast. */
     timeout?: number;
 }
+/** The kind of queue mutation that triggered a notification, passed to `wrapUpdate`. */
+export type ToastAction = "add" | "remove" | "clear";
 export interface ToastQueueOptions {
     /** The maximum number of toasts to display at once. */
     maxVisibleToasts?: number;
     /** Whether toasts should stack (true) or queue (false). */
     hasExitAnimation?: boolean;
+    /**
+     * Wraps each update to the visible toasts (e.g. in `document.startViewTransition()`),
+     * so the resulting re-render can be animated. Receives the action that triggered the
+     * update. Mirrors `@react-stately/toast`'s `wrapUpdate`.
+     */
+    wrapUpdate?: (fn: () => void, action: ToastAction) => void;
 }
 export interface ToastStateProps<T> {
     /** The toast queue to use. */
@@ -82,7 +90,15 @@ export declare class ToastQueue<T> {
     private maxVisibleToasts;
     private hasExitAnimation;
     private keyCounter;
+    private wrapUpdate?;
     constructor(options?: ToastQueueOptions);
+    /**
+     * Installs (or clears) the function that wraps visible-toast updates, so the
+     * resulting re-render can be animated. Used to attach `document.startViewTransition`
+     * to a shared queue (e.g. the global queue) after construction.
+     */
+    setWrapUpdate(wrapUpdate?: (fn: () => void, action: ToastAction) => void): void;
+    private runWithWrapUpdate;
     /**
      * Subscribe to queue changes.
      */

package/dist/toast/index.d.ts

@@ -1 +1 @@
-export { createToastState, createToastQueue, ToastQueue, Timer, type ToastOptions, type QueuedToast, type ToastQueueOptions, type ToastStateProps, type ToastState, } from "./createToastState";
+export { createToastState, createToastQueue, ToastQueue, Timer, type ToastOptions, type QueuedToast, type ToastQueueOptions, type ToastAction, type ToastStateProps, type ToastState, } from "./createToastState";

package/dist/tree/types.d.ts

@@ -2,7 +2,7 @@
  * Tree collection types for Tree components.
  * Based on @react-stately/tree.
  */
-import type { Key, FocusStrategy } from "../collections/types";
+import type { Key, FocusStrategy, Selection, SelectionBehavior } from "../collections/types";
 import type { GridNode, GridCollection } from "../grid/types";
 /**
  * Represents a node in a tree collection.
@@ -63,6 +63,8 @@ export interface TreeState<T, C extends TreeCollection<T> = TreeCollection<T>> {
     readonly collection: C;
     /** Keys of disabled items. */
     readonly disabledKeys: Set<Key>;
+    /** Whether `disabledKeys` applies to all interactions, or only selection. */
+    readonly disabledBehavior: "selection" | "all";
     /** Keys of expanded items. */
     readonly expandedKeys: Set<Key>;
     /** Whether keyboard navigation is disabled. */
@@ -76,9 +78,11 @@ export interface TreeState<T, C extends TreeCollection<T> = TreeCollection<T>> {
     /** The selection mode. */
     readonly selectionMode: "none" | "single" | "multiple";
     /** How selection behaves when pressing an item. */
-    readonly selectionBehavior: "toggle" | "replace";
+    readonly selectionBehavior: SelectionBehavior;
+    /** Whether empty selection is disallowed. */
+    readonly disallowEmptySelection: boolean;
     /** The currently selected keys. */
-    readonly selectedKeys: "all" | Set<Key>;
+    readonly selectedKeys: Selection;
     /** Check if a key is selected. */
     isSelected(key: Key): boolean;
     /** Check if a key is disabled. */
@@ -93,6 +97,10 @@ export interface TreeState<T, C extends TreeCollection<T> = TreeCollection<T>> {
     toggleSelection(key: Key): void;
     /** Replace selection with a key. */
     replaceSelection(key: Key): void;
+    /** Set the selected keys directly. */
+    setSelectedKeys(keys: Selection | Iterable<Key>): void;
+    /** Set how selection behaves when pressing an item. */
+    setSelectionBehavior(behavior: SelectionBehavior): void;
     /** Extend selection to a key (shift-click). */
     extendSelection(toKey: Key): void;
     /** Select all visible items. */
@@ -125,13 +133,13 @@ export interface TreeStateOptions<T, C extends TreeCollection<T> = TreeCollectio
     /** Selection mode. */
     selectionMode?: "none" | "single" | "multiple";
     /** Selection behavior. */
-    selectionBehavior?: "toggle" | "replace";
+    selectionBehavior?: SelectionBehavior;
     /** Whether empty selection is disallowed. */
     disallowEmptySelection?: boolean;
     /** Currently selected keys (controlled). */
-    selectedKeys?: "all" | Iterable<Key>;
+    selectedKeys?: Selection | Iterable<Key>;
     /** Default selected keys (uncontrolled). */
-    defaultSelectedKeys?: "all" | Iterable<Key>;
+    defaultSelectedKeys?: Selection | Iterable<Key>;
     /** Handler for selection changes. */
     onSelectionChange?: (keys: "all" | Set<Key>) => void;
     /** Currently expanded keys (controlled). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proyecto-viviana/solid-stately",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A 1-1 SolidJS port of React Stately - headless state management for UI components",
   "keywords": [
     "headless",