@proyecto-viviana/solid-stately 0.2.7 → 0.4.0

package/dist/menu/index.d.ts

@@ -4,5 +4,5 @@
  * Exposes React Stately-like menu hook names while using existing
  * Solid menu state primitives.
  */
-export { createMenuState, createMenuTriggerState, type MenuStateProps, type MenuState, type MenuTriggerStateProps, type MenuTriggerState, } from '../collections/createMenuState';
-export { createMenuTriggerState as useMenuTriggerState, } from '../collections/createMenuState';
+export { createMenuState, createMenuTriggerState, type MenuStateProps, type MenuState, type MenuTriggerStateProps, type MenuTriggerState, } from "../collections/createMenuState";
+export { createMenuTriggerState as useMenuTriggerState } from "../collections/createMenuState";

package/dist/numberfield/createNumberFieldState.d.ts

@@ -2,8 +2,8 @@
  * State management for NumberField.
  * Based on @react-stately/numberfield useNumberFieldState.
  */
-import { type Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
+import { type Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
 export interface NumberFieldStateProps {
     /** The current value (controlled). */
     value?: number;

package/dist/numberfield/index.d.ts

@@ -1 +1 @@
-export { createNumberFieldState, type NumberFieldStateProps, type NumberFieldState, } from './createNumberFieldState';
+export { createNumberFieldState, type NumberFieldStateProps, type NumberFieldState, } from "./createNumberFieldState";

package/dist/overlays/createOverlayTriggerState.d.ts

@@ -2,8 +2,8 @@
  * Manages state for an overlay trigger.
  * Based on @react-stately/overlays useOverlayTriggerState.
  */
-import { type Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
+import { type Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
 export interface OverlayTriggerProps {
     /** Whether the overlay is open by default (uncontrolled). */
     defaultOpen?: boolean;

package/dist/overlays/index.d.ts

@@ -1 +1 @@
-export { createOverlayTriggerState, type OverlayTriggerProps, type OverlayTriggerState, } from './createOverlayTriggerState';
+export { createOverlayTriggerState, type OverlayTriggerProps, type OverlayTriggerState, } from "./createOverlayTriggerState";

package/dist/radio/createRadioGroupState.d.ts

@@ -6,9 +6,9 @@
  *
  * This is a 1:1 port of @react-stately/radio's useRadioGroupState.
  */
-import { Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
-import { type FormValidationState, type ValidationFunction, type ValidationResult } from '../form';
+import { Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
+import { type FormValidationState, type ValidationFunction, type ValidationResult } from "../form";
 export interface RadioGroupProps {
     /** The current selected value (controlled). */
     value?: string | null;
@@ -31,7 +31,7 @@ export interface RadioGroupProps {
     /** The label for the radio group. */
     label?: string;
     /** Orientation of the radio group. */
-    orientation?: 'horizontal' | 'vertical';
+    orientation?: "horizontal" | "vertical";
     /** Handler that is called when the radio group receives focus. */
     onFocus?: (e: FocusEvent) => void;
     /** Handler that is called when the radio group loses focus. */
@@ -39,13 +39,13 @@ export interface RadioGroupProps {
     /** Handler that is called when the radio group's focus status changes. */
     onFocusChange?: (isFocused: boolean) => void;
     /** Backward-compatible controlled validation state. */
-    validationState?: 'valid' | 'invalid';
+    validationState?: "valid" | "invalid";
     /** Custom validation function. */
     validate?: ValidationFunction<string | null>;
     /** Validation behavior for the radio group. */
-    validationBehavior?: 'aria' | 'native';
+    validationBehavior?: "aria" | "native";
 }
-export interface RadioGroupState extends Pick<FormValidationState, 'realtimeValidation' | 'displayValidation' | 'updateValidation' | 'resetValidation' | 'commitValidation'> {
+export interface RadioGroupState extends Pick<FormValidationState, "realtimeValidation" | "displayValidation" | "updateValidation" | "resetValidation" | "commitValidation"> {
     /** The name for the group, used for native form submission. */
     readonly name: string;
     /** Whether the radio group is disabled. */

package/dist/radio/index.d.ts

@@ -1 +1 @@
-export { createRadioGroupState, radioGroupSyncVersion, type RadioGroupProps, type RadioGroupState, } from './createRadioGroupState';
+export { createRadioGroupState, radioGroupSyncVersion, type RadioGroupProps, type RadioGroupState, } from "./createRadioGroupState";

package/dist/searchfield/createSearchFieldState.d.ts

@@ -2,8 +2,8 @@
  * Creates state for a search field component.
  * Based on @react-stately/searchfield useSearchFieldState.
  */
-import { type Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
+import { type Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
 export interface SearchFieldStateProps {
     /** The current value (controlled). */
     value?: string;

package/dist/searchfield/index.d.ts

@@ -1,2 +1,2 @@
-export { createSearchFieldState } from './createSearchFieldState';
-export type { SearchFieldState, SearchFieldStateProps, } from './createSearchFieldState';
+export { createSearchFieldState } from "./createSearchFieldState";
+export type { SearchFieldState, SearchFieldStateProps } from "./createSearchFieldState";

package/dist/select/createSelectState.d.ts

@@ -2,10 +2,11 @@
  * State management for select components.
  * Based on @react-stately/select useSelectState.
  */
-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 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[];
@@ -22,15 +23,15 @@ export interface SelectStateProps<T = unknown> {
     /** The default selected key (uncontrolled). */
     defaultSelectedKey?: Key | null;
     /** The selected keys (controlled, for multiple selection mode). */
-    selectedKeys?: 'all' | Iterable<Key>;
+    selectedKeys?: "all" | Iterable<Key>;
     /** Default selected keys (uncontrolled, for multiple selection mode). */
-    defaultSelectedKeys?: 'all' | Iterable<Key>;
+    defaultSelectedKeys?: "all" | Iterable<Key>;
     /** Handler called when the selection changes. */
     onSelectionChange?: (key: Key | null) => void;
     /** Handler called when selected keys change. */
     onSelectionChangeKeys?: (keys: Selection) => void;
     /** Selection mode for the select. */
-    selectionMode?: Extract<SelectionMode, 'single' | 'multiple'>;
+    selectionMode?: Extract<SelectionMode, "single" | "multiple">;
     /** Whether the select is open (controlled). */
     isOpen?: boolean;
     /** Whether the select is open by default (uncontrolled). */
@@ -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. */
@@ -80,7 +86,7 @@ export interface SelectState<T = unknown> {
     /** Whether the select is required. */
     readonly isRequired: boolean;
     /** The selection mode. */
-    readonly selectionMode: Accessor<'single' | 'multiple'>;
+    readonly selectionMode: Accessor<"single" | "multiple">;
 }
 /**
  * Creates state for a select component.

package/dist/select/index.d.ts

@@ -1 +1 @@
-export { createSelectState, type SelectStateProps, type SelectState, } from './createSelectState';
+export { createSelectState, type SelectStateProps, type SelectState } from "./createSelectState";

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,110 @@
+/**
+ * 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>;
+}

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

@@ -4,8 +4,9 @@
  * Provides a React Stately-like module entrypoint for selection state while
  * delegating to the existing Solid collection selection primitives.
  */
-export { createSelectionState, type SelectionStateProps, type SelectionState, } from '../collections/createSelectionState';
-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;
-export { createSelectionState as useMultipleSelectionState, } from '../collections/createSelectionState';
+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;
+export { createSelectionState as useMultipleSelectionState } from "../collections/createSelectionState";

package/dist/slider/createSliderState.d.ts

@@ -2,9 +2,9 @@
  * Creates state for a slider component.
  * Based on @react-stately/slider useSliderState.
  */
-import { type Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
-export type SliderOrientation = 'horizontal' | 'vertical';
+import { type Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
+export type SliderOrientation = "horizontal" | "vertical";
 export interface SliderStateProps {
     /** The current value (controlled). */
     value?: number;

package/dist/slider/index.d.ts

@@ -1,2 +1,2 @@
-export { createSliderState } from './createSliderState';
-export type { SliderState, SliderStateProps, SliderOrientation, } from './createSliderState';
+export { createSliderState } from "./createSliderState";
+export type { SliderState, SliderStateProps, SliderOrientation } from "./createSliderState";

package/dist/steplist/createStepListState.d.ts

@@ -0,0 +1,48 @@
+/**
+ * State management for step list components.
+ * Tracks selected step, completion status, and selectability.
+ */
+import { type Accessor } from "solid-js";
+import type { Key } from "../collections/types";
+export interface StepListStateProps {
+    /** The currently selected step key (controlled). */
+    selectedKey?: Key;
+    /** The default selected step key (uncontrolled). */
+    defaultSelectedKey?: Key;
+    /** Called when the selected step changes. */
+    onSelectionChange?: (key: Key) => void;
+    /** The last completed step key (controlled). */
+    lastCompletedStep?: Key;
+    /** The default last completed step key (uncontrolled). */
+    defaultLastCompletedStep?: Key;
+    /** Called when last completed step changes. */
+    onLastCompletedStepChange?: (key: Key | null) => void;
+    /** Whether all steps are disabled. */
+    isDisabled?: boolean;
+    /** Whether all steps are read-only. */
+    isReadOnly?: boolean;
+    /** Keys of individually disabled steps. */
+    disabledKeys?: Iterable<Key>;
+    /** The step items. */
+    items: Array<{
+        key: Key;
+        [key: string]: any;
+    }>;
+}
+export interface StepListState {
+    readonly selectedKey: Accessor<Key | null>;
+    readonly lastCompletedStep: Accessor<Key | null>;
+    readonly items: Accessor<Array<{
+        key: Key;
+    }>>;
+    setSelectedKey(key: Key): void;
+    setLastCompletedStep(key: Key): void;
+    isCompleted(key: Key): boolean;
+    isSelectable(key: Key): boolean;
+    isDisabled: Accessor<boolean>;
+    isReadOnly: Accessor<boolean>;
+}
+/**
+ * Creates state for a step list component.
+ */
+export declare function createStepListState(props: StepListStateProps): StepListState;

package/dist/steplist/index.d.ts

@@ -0,0 +1 @@
+export { createStepListState, type StepListStateProps, type StepListState, } from "./createStepListState";

package/dist/table/TableCollection.d.ts

@@ -1,10 +1,16 @@
 /**
  * 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';
-import type { TableCollection as ITableCollection, TableCollectionOptions } from './types';
+import type { Key } from "../collections/types";
+import type { GridNode } from "../grid/types";
+import type { TableCollection as ITableCollection, TableCollectionOptions } from "./types";
 /**
  * Creates a table collection from column and row definitions.
  */
@@ -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/createTableColumnResizeState.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Table column resize state management.
+ * Based on @react-stately/table/useTableColumnResizeState.
+ *
+ * Provides column width state management for a table with column resizing.
+ * Tracks column widths, the currently resizing column, and handles
+ * width distribution and clamping.
+ */
+import { type Accessor } from "solid-js";
+import type { Key } from "../collections/types";
+/** Column size: a number (px) or a string ('100px', '50%', '1fr'). */
+export type ColumnSize = number | string;
+export interface ColumnResizeDefinition {
+    /** The column key. */
+    key: Key;
+    /** The width of the column. Numbers are px, strings can be 'Xfr', 'Xpx', or 'X%'. */
+    width?: ColumnSize;
+    /** Minimum width in pixels. Default: 75. */
+    minWidth?: number;
+    /** Maximum width in pixels. Default: Infinity. */
+    maxWidth?: number;
+}
+export interface TableColumnResizeStateProps {
+    /** Current width of the table or table viewport. */
+    tableWidth: number;
+    /** Column definitions with width/min/max. */
+    columns: ColumnResizeDefinition[];
+}
+export interface TableColumnResizeState {
+    /** The key of the column currently being resized, or null. */
+    readonly resizingColumn: Accessor<Key | null>;
+    /** A reactive map of computed column widths in pixels. */
+    readonly columnWidths: Accessor<Map<Key, number>>;
+    /** Begin a resize operation for the given column. */
+    startResize(key: Key): void;
+    /** End the current resize operation. */
+    endResize(): void;
+    /** Update column widths during a resize drag. Returns the new widths map. */
+    updateResizedColumns(key: Key, width: number): Map<Key, number>;
+    /** Get the current computed width for a column. */
+    getColumnWidth(key: Key): number;
+    /** Get the minimum width for a column. */
+    getColumnMinWidth(key: Key): number;
+    /** Get the maximum width for a column. */
+    getColumnMaxWidth(key: Key): number;
+}
+/**
+ * Creates column resize state for a table component.
+ *
+ * Builds an initial column width map from column definitions + table width,
+ * then tracks resize operations that clamp to min/max and redistribute
+ * remaining space among flex columns.
+ */
+export declare function createTableColumnResizeState(props: Accessor<TableColumnResizeStateProps>): TableColumnResizeState;

package/dist/table/createTableState.d.ts

@@ -2,8 +2,8 @@
  * Table state management for Table components.
  * Based on @react-stately/table/useTableState.
  */
-import { type Accessor } from 'solid-js';
-import type { TableState, TableStateOptions, TableCollection } from './types';
+import { type Accessor } from "solid-js";
+import type { TableState, TableStateOptions, TableCollection } from "./types";
 /**
  * Creates state management for a table component.
  * Extends grid state with sorting and table-specific features.

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

@@ -2,6 +2,9 @@
  * Table state management module.
  * Provides state hooks for Table components.
  */
-export { createTableState } from './createTableState';
-export { TableCollection, createTableCollection } from './TableCollection';
-export type { TableState, TableStateOptions, TableCollection as ITableCollection, SortDescriptor, SortDirection, Sortable, ColumnDefinition, RowDefinition, TableCollectionOptions, } from './types';
+export { createTableState } from "./createTableState";
+export { createTreeGridState } from "./createTreeGridState";
+export { createTableColumnResizeState } from "./createTableColumnResizeState";
+export { TableCollection, createTableCollection } from "./TableCollection";
+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";