@proyecto-viviana/solid-stately 0.2.7 → 0.3.0

package/src/tree/createTreeState.ts

@@ -5,21 +5,16 @@
  * Manages expansion state, selection, and focus for hierarchical tree data.
  */
 
-import { createSignal, createEffect, createMemo, on, type Accessor } from 'solid-js';
-import type {
-  TreeState,
-  TreeStateOptions,
-  TreeCollection,
-  TreeNode,
-} from './types';
-import type { Key, FocusStrategy } from '../collections/types';
+import { createSignal, createEffect, createMemo, on, type Accessor } from "solid-js";
+import type { TreeState, TreeStateOptions, TreeCollection, TreeNode } from "./types";
+import type { Key, FocusStrategy } from "../collections/types";
 
 /**
  * Creates state management for a tree component.
  * Handles expansion, selection, focus management, and keyboard navigation state.
  */
 export function createTreeState<T extends object, C extends TreeCollection<T> = TreeCollection<T>>(
-  options: Accessor<TreeStateOptions<T, C>>
+  options: Accessor<TreeStateOptions<T, C>>,
 ): TreeState<T, C> {
   const getOptions = () => options();
 
@@ -31,7 +26,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
 
   // Expansion state (uncontrolled)
   const [internalExpandedKeys, setInternalExpandedKeys] = createSignal<Set<Key>>(
-    getInitialExpandedKeys(getOptions().defaultExpandedKeys)
+    getInitialExpandedKeys(getOptions().defaultExpandedKeys),
   );
 
   // Computed expanded keys (controlled or uncontrolled)
@@ -56,8 +51,8 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   const [isKeyboardNavigationDisabled, setKeyboardNavigationDisabled] = createSignal(false);
 
   // Selection state
-  const [internalSelectedKeys, setInternalSelectedKeys] = createSignal<'all' | Set<Key>>(
-    getInitialSelection(getOptions().defaultSelectedKeys)
+  const [internalSelectedKeys, setInternalSelectedKeys] = createSignal<"all" | Set<Key>>(
+    getInitialSelection(getOptions().defaultSelectedKeys),
   );
   const [anchorKey, setAnchorKey] = createSignal<Key | null>(null);
 
@@ -70,13 +65,13 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
     return internalSelectedKeys();
   });
 
-  const selectionMode = createMemo(() => getOptions().selectionMode ?? 'none');
-  const selectionBehavior = createMemo(() => getOptions().selectionBehavior ?? 'toggle');
+  const selectionMode = createMemo(() => getOptions().selectionMode ?? "none");
+  const selectionBehavior = createMemo(() => getOptions().selectionBehavior ?? "toggle");
   const disallowEmptySelection = createMemo(() => getOptions().disallowEmptySelection ?? false);
-  const disabledBehavior = createMemo(() => getOptions().disabledBehavior ?? 'all');
+  const disabledBehavior = createMemo(() => getOptions().disabledBehavior ?? "all");
 
   // Set focused key
-  const setFocusedKey = (key: Key | null, strategy: FocusStrategy = 'first') => {
+  const setFocusedKey = (key: Key | null, strategy: FocusStrategy = "first") => {
     setFocusedKeyInternal(key);
     setChildFocusStrategy(strategy);
   };
@@ -132,25 +127,25 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
       }
 
       cachedCollection = coll;
-    })
+    }),
   );
 
   // Selection methods
   const isSelected = (key: Key): boolean => {
     const keys = selectedKeys();
-    if (keys === 'all') return true;
+    if (keys === "all") return true;
     return keys.has(key);
   };
 
   const isDisabled = (key: Key): boolean => {
-    return disabledKeys().has(key);
+    return disabledKeys().has(key) || collection().getItem(key)?.isDisabled === true;
   };
 
   const isExpanded = (key: Key): boolean => {
     return expandedKeys().has(key);
   };
 
-  const updateSelection = (newSelection: 'all' | Set<Key>) => {
+  const updateSelection = (newSelection: "all" | Set<Key>) => {
     const opts = getOptions();
 
     // Controlled mode
@@ -162,8 +157,8 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
     // Uncontrolled mode
     const current = internalSelectedKeys();
     const isDifferent =
-      current === 'all' ||
-      newSelection === 'all' ||
+      current === "all" ||
+      newSelection === "all" ||
       current.size !== (newSelection as Set<Key>).size ||
       ![...current].every((k) => (newSelection as Set<Key>).has(k));
 
@@ -174,12 +169,12 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   };
 
   const toggleSelection = (key: Key) => {
-    if (isDisabled(key) && disabledBehavior() === 'all') return;
-    if (selectionMode() === 'none') return;
+    if (isDisabled(key) && disabledBehavior() === "all") return;
+    if (selectionMode() === "none") return;
 
     const current = selectedKeys();
 
-    if (selectionMode() === 'single') {
+    if (selectionMode() === "single") {
       if (isSelected(key) && !disallowEmptySelection()) {
         updateSelection(new Set());
       } else {
@@ -189,7 +184,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
     }
 
     // Multiple selection
-    if (current === 'all') {
+    if (current === "all") {
       // Can't toggle when all selected without knowing all keys
       return;
     }
@@ -208,16 +203,16 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   };
 
   const replaceSelection = (key: Key) => {
-    if (isDisabled(key) && disabledBehavior() === 'all') return;
-    if (selectionMode() === 'none') return;
+    if (isDisabled(key) && disabledBehavior() === "all") return;
+    if (selectionMode() === "none") return;
 
     updateSelection(new Set([key]));
     setAnchorKey(key);
   };
 
   const extendSelection = (toKey: Key) => {
-    if (isDisabled(toKey) && disabledBehavior() === 'all') return;
-    if (selectionMode() !== 'multiple') {
+    if (isDisabled(toKey) && disabledBehavior() === "all") return;
+    if (selectionMode() !== "multiple") {
       replaceSelection(toKey);
       return;
     }
@@ -229,7 +224,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
     }
 
     const coll = collection();
-    const rows = coll.rows.filter((r) => r.type === 'item');
+    const rows = coll.rows.filter((r) => r.type === "item");
     const keys = rows.map((r) => r.key);
     const anchorIndex = keys.indexOf(anchor);
     const toIndex = keys.indexOf(toKey);
@@ -247,8 +242,8 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   };
 
   const selectAll = () => {
-    if (selectionMode() !== 'multiple') return;
-    updateSelection('all');
+    if (selectionMode() !== "multiple") return;
+    updateSelection("all");
   };
 
   const clearSelection = () => {
@@ -257,9 +252,9 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   };
 
   const toggleSelectAll = () => {
-    if (selectionMode() !== 'multiple') return;
+    if (selectionMode() !== "multiple") return;
 
-    if (selectedKeys() === 'all') {
+    if (selectedKeys() === "all") {
       clearSelection();
     } else {
       selectAll();
@@ -284,7 +279,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   const toggleKey = (key: Key) => {
     const node = collection().getItem(key);
     if (!node || !node.isExpandable) return;
-    if (isDisabled(key) && disabledBehavior() === 'all') return;
+    if (isDisabled(key) && disabledBehavior() === "all") return;
 
     const current = expandedKeys();
     const newKeys = new Set(current);
@@ -301,7 +296,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   const expandKey = (key: Key) => {
     const node = collection().getItem(key);
     if (!node || !node.isExpandable) return;
-    if (isDisabled(key) && disabledBehavior() === 'all') return;
+    if (isDisabled(key) && disabledBehavior() === "all") return;
 
     const current = expandedKeys();
     if (current.has(key)) return;
@@ -314,7 +309,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   const collapseKey = (key: Key) => {
     const node = collection().getItem(key);
     if (!node || !node.isExpandable) return;
-    if (isDisabled(key) && disabledBehavior() === 'all') return;
+    if (isDisabled(key) && disabledBehavior() === "all") return;
 
     const current = expandedKeys();
     if (!current.has(key)) return;
@@ -353,6 +348,9 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
     get selectionMode() {
       return selectionMode();
     },
+    get selectionBehavior() {
+      return selectionBehavior();
+    },
     get selectedKeys() {
       return selectedKeys();
     },
@@ -376,13 +374,13 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
 }
 
 // Helper functions
-function getInitialSelection(defaultKeys?: 'all' | Iterable<Key>): 'all' | Set<Key> {
+function getInitialSelection(defaultKeys?: "all" | Iterable<Key>): "all" | Set<Key> {
   if (defaultKeys === undefined) return new Set();
   return normalizeSelection(defaultKeys);
 }
 
-function normalizeSelection(keys: 'all' | Iterable<Key>): 'all' | Set<Key> {
-  if (keys === 'all') return 'all';
+function normalizeSelection(keys: "all" | Iterable<Key>): "all" | Set<Key> {
+  if (keys === "all") return "all";
   return new Set(keys);
 }
 

package/src/tree/index.d.ts

@@ -1,7 +1,13 @@
 /**
  * Tree state management exports.
  */
-export { createTreeState } from './createTreeState';
-export { TreeCollection, createTreeCollection } from './TreeCollection';
-export type { TreeState, TreeStateOptions, TreeCollection as TreeCollectionInterface, TreeNode, TreeItemData, } from './types';
-//# sourceMappingURL=index.d.ts.map
+export { createTreeState } from "./createTreeState";
+export { TreeCollection, createTreeCollection } from "./TreeCollection";
+export type {
+  TreeState,
+  TreeStateOptions,
+  TreeCollection as TreeCollectionInterface,
+  TreeNode,
+  TreeItemData,
+} from "./types";
+//# sourceMappingURL=index.d.ts.map

package/src/tree/index.ts

@@ -2,12 +2,12 @@
  * Tree state management exports.
  */
 
-export { createTreeState } from './createTreeState';
-export { TreeCollection, createTreeCollection } from './TreeCollection';
+export { createTreeState } from "./createTreeState";
+export { TreeCollection, createTreeCollection } from "./TreeCollection";
 export type {
   TreeState,
   TreeStateOptions,
   TreeCollection as TreeCollectionInterface,
   TreeNode,
   TreeItemData,
-} from './types';
+} from "./types";

package/src/tree/types.d.ts

@@ -2,156 +2,161 @@
  * Tree collection types for Tree components.
  * Based on @react-stately/tree.
  */
-import type { Key, FocusStrategy } from '../collections/types';
-import type { GridNode, GridCollection } from '../grid/types';
+import type { Key, FocusStrategy } from "../collections/types";
+import type { GridNode, GridCollection } from "../grid/types";
 /**
  * Represents a node in a tree collection.
  * Extends GridNode with tree-specific properties.
  */
 export interface TreeNode<T = unknown> extends GridNode<T> {
-    /** Whether this node has child nodes that can be expanded. */
-    hasChildNodes: boolean;
-    /** Child nodes of this tree item. */
-    childNodes: TreeNode<T>[];
-    /** The level of nesting (0 for root items). */
-    level: number;
-    /** The key of the parent node, if any. */
-    parentKey?: Key | null;
-    /** Whether this node is expandable. */
-    isExpandable?: boolean;
-    /** Whether this node is currently expanded (only meaningful if expandable). */
-    isExpanded?: boolean;
+  /** Whether this node has child nodes that can be expanded. */
+  hasChildNodes: boolean;
+  /** Child nodes of this tree item. */
+  childNodes: TreeNode<T>[];
+  /** The level of nesting (0 for root items). */
+  level: number;
+  /** The key of the parent node, if any. */
+  parentKey?: Key | null;
+  /** Whether this node is expandable. */
+  isExpandable?: boolean;
+  /** Whether this node is currently expanded (only meaningful if expandable). */
+  isExpanded?: boolean;
 }
 /**
  * A collection of tree nodes with tree-specific navigation.
  * Only includes visible nodes (respects expanded state).
  */
-export interface TreeCollection<T = unknown> extends Omit<GridCollection<T>, 'rows' | 'columns' | 'headerRows' | 'columnCount' | 'getCell'> {
-    /** All visible rows in the tree (respects expanded state). */
-    readonly rows: TreeNode<T>[];
-    /** Number of visible rows. */
-    readonly rowCount: number;
-    /** Get all keys in the collection (visible only). */
-    getKeys(): Iterable<Key>;
-    /** Get a node by its key (any node, visible or not). */
-    getItem(key: Key): TreeNode<T> | null;
-    /** Get a node by index (visible nodes only). */
-    at(index: number): TreeNode<T> | null;
-    /** Get the key before the given key (visible nodes only). */
-    getKeyBefore(key: Key): Key | null;
-    /** Get the key after the given key (visible nodes only). */
-    getKeyAfter(key: Key): Key | null;
-    /** Get the first key in the collection. */
-    getFirstKey(): Key | null;
-    /** Get the last key in the collection. */
-    getLastKey(): Key | null;
-    /** Get the children of a node. */
-    getChildren(key: Key): Iterable<TreeNode<T>>;
-    /** Get the text value for a key. */
-    getTextValue(key: Key): string;
-    /** Get the parent key for a node. */
-    getParentKey(key: Key): Key | null;
-    /** Iterator over visible nodes. */
-    [Symbol.iterator](): Iterator<TreeNode<T>>;
+export interface TreeCollection<T = unknown> extends Omit<
+  GridCollection<T>,
+  "rows" | "columns" | "headerRows" | "columnCount" | "getCell"
+> {
+  /** All visible rows in the tree (respects expanded state). */
+  readonly rows: TreeNode<T>[];
+  /** Number of visible rows. */
+  readonly rowCount: number;
+  /** Get all keys in the collection (visible only). */
+  getKeys(): Iterable<Key>;
+  /** Get a node by its key (any node, visible or not). */
+  getItem(key: Key): TreeNode<T> | null;
+  /** Get a node by index (visible nodes only). */
+  at(index: number): TreeNode<T> | null;
+  /** Get the key before the given key (visible nodes only). */
+  getKeyBefore(key: Key): Key | null;
+  /** Get the key after the given key (visible nodes only). */
+  getKeyAfter(key: Key): Key | null;
+  /** Get the first key in the collection. */
+  getFirstKey(): Key | null;
+  /** Get the last key in the collection. */
+  getLastKey(): Key | null;
+  /** Get the children of a node. */
+  getChildren(key: Key): Iterable<TreeNode<T>>;
+  /** Get the text value for a key. */
+  getTextValue(key: Key): string;
+  /** Get the parent key for a node. */
+  getParentKey(key: Key): Key | null;
+  /** Iterator over visible nodes. */
+  [Symbol.iterator](): Iterator<TreeNode<T>>;
 }
 /**
  * State for a tree component.
  * Extends grid state with expansion management.
  */
 export interface TreeState<T, C extends TreeCollection<T> = TreeCollection<T>> {
-    /** The tree collection (only visible nodes). */
-    readonly collection: C;
-    /** Keys of disabled items. */
-    readonly disabledKeys: Set<Key>;
-    /** Keys of expanded items. */
-    readonly expandedKeys: Set<Key>;
-    /** Whether keyboard navigation is disabled. */
-    readonly isKeyboardNavigationDisabled: boolean;
-    /** Currently focused key. */
-    readonly focusedKey: Key | null;
-    /** Focus strategy for child focus. */
-    readonly childFocusStrategy: FocusStrategy | null;
-    /** Whether the tree is focused. */
-    readonly isFocused: boolean;
-    /** The selection mode. */
-    readonly selectionMode: 'none' | 'single' | 'multiple';
-    /** The currently selected keys. */
-    readonly selectedKeys: 'all' | Set<Key>;
-    /** Check if a key is selected. */
-    isSelected(key: Key): boolean;
-    /** Check if a key is disabled. */
-    isDisabled(key: Key): boolean;
-    /** Check if a key is expanded. */
-    isExpanded(key: Key): boolean;
-    /** Set the focused key. */
-    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy): void;
-    /** Set focused state. */
-    setFocused(isFocused: boolean): void;
-    /** Toggle selection for a key. */
-    toggleSelection(key: Key): void;
-    /** Replace selection with a key. */
-    replaceSelection(key: Key): void;
-    /** Extend selection to a key (shift-click). */
-    extendSelection(toKey: Key): void;
-    /** Select all visible items. */
-    selectAll(): void;
-    /** Clear selection. */
-    clearSelection(): void;
-    /** Toggle select all. */
-    toggleSelectAll(): void;
-    /** Toggle expansion for a key. */
-    toggleKey(key: Key): void;
-    /** Expand a key. */
-    expandKey(key: Key): void;
-    /** Collapse a key. */
-    collapseKey(key: Key): void;
-    /** Set the expanded keys. */
-    setExpandedKeys(keys: Set<Key>): void;
-    /** Set keyboard navigation disabled. */
-    setKeyboardNavigationDisabled(isDisabled: boolean): void;
+  /** The tree collection (only visible nodes). */
+  readonly collection: C;
+  /** Keys of disabled items. */
+  readonly disabledKeys: Set<Key>;
+  /** Keys of expanded items. */
+  readonly expandedKeys: Set<Key>;
+  /** Whether keyboard navigation is disabled. */
+  readonly isKeyboardNavigationDisabled: boolean;
+  /** Currently focused key. */
+  readonly focusedKey: Key | null;
+  /** Focus strategy for child focus. */
+  readonly childFocusStrategy: FocusStrategy | null;
+  /** Whether the tree is focused. */
+  readonly isFocused: boolean;
+  /** The selection mode. */
+  readonly selectionMode: "none" | "single" | "multiple";
+  /** How selection behaves when pressing an item. */
+  readonly selectionBehavior: "toggle" | "replace";
+  /** The currently selected keys. */
+  readonly selectedKeys: "all" | Set<Key>;
+  /** Check if a key is selected. */
+  isSelected(key: Key): boolean;
+  /** Check if a key is disabled. */
+  isDisabled(key: Key): boolean;
+  /** Check if a key is expanded. */
+  isExpanded(key: Key): boolean;
+  /** Set the focused key. */
+  setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy): void;
+  /** Set focused state. */
+  setFocused(isFocused: boolean): void;
+  /** Toggle selection for a key. */
+  toggleSelection(key: Key): void;
+  /** Replace selection with a key. */
+  replaceSelection(key: Key): void;
+  /** Extend selection to a key (shift-click). */
+  extendSelection(toKey: Key): void;
+  /** Select all visible items. */
+  selectAll(): void;
+  /** Clear selection. */
+  clearSelection(): void;
+  /** Toggle select all. */
+  toggleSelectAll(): void;
+  /** Toggle expansion for a key. */
+  toggleKey(key: Key): void;
+  /** Expand a key. */
+  expandKey(key: Key): void;
+  /** Collapse a key. */
+  collapseKey(key: Key): void;
+  /** Set the expanded keys. */
+  setExpandedKeys(keys: Set<Key>): void;
+  /** Set keyboard navigation disabled. */
+  setKeyboardNavigationDisabled(isDisabled: boolean): void;
 }
 /**
  * Options for creating tree state.
  */
 export interface TreeStateOptions<T, C extends TreeCollection<T> = TreeCollection<T>> {
-    /** The tree collection builder - receives expanded keys and returns collection. */
-    collectionFactory: (expandedKeys: Set<Key>) => C;
-    /** Keys of disabled items. */
-    disabledKeys?: Iterable<Key>;
-    /** Disabled behavior: 'selection' only or 'all' interactions. */
-    disabledBehavior?: 'selection' | 'all';
-    /** Selection mode. */
-    selectionMode?: 'none' | 'single' | 'multiple';
-    /** Selection behavior. */
-    selectionBehavior?: 'toggle' | 'replace';
-    /** Whether empty selection is disallowed. */
-    disallowEmptySelection?: boolean;
-    /** Currently selected keys (controlled). */
-    selectedKeys?: 'all' | Iterable<Key>;
-    /** Default selected keys (uncontrolled). */
-    defaultSelectedKeys?: 'all' | Iterable<Key>;
-    /** Handler for selection changes. */
-    onSelectionChange?: (keys: 'all' | Set<Key>) => void;
-    /** Currently expanded keys (controlled). */
-    expandedKeys?: Iterable<Key>;
-    /** Default expanded keys (uncontrolled). */
-    defaultExpandedKeys?: Iterable<Key>;
-    /** Handler for expansion changes. */
-    onExpandedChange?: (keys: Set<Key>) => void;
+  /** The tree collection builder - receives expanded keys and returns collection. */
+  collectionFactory: (expandedKeys: Set<Key>) => C;
+  /** Keys of disabled items. */
+  disabledKeys?: Iterable<Key>;
+  /** Disabled behavior: 'selection' only or 'all' interactions. */
+  disabledBehavior?: "selection" | "all";
+  /** Selection mode. */
+  selectionMode?: "none" | "single" | "multiple";
+  /** Selection behavior. */
+  selectionBehavior?: "toggle" | "replace";
+  /** Whether empty selection is disallowed. */
+  disallowEmptySelection?: boolean;
+  /** Currently selected keys (controlled). */
+  selectedKeys?: "all" | Iterable<Key>;
+  /** Default selected keys (uncontrolled). */
+  defaultSelectedKeys?: "all" | Iterable<Key>;
+  /** Handler for selection changes. */
+  onSelectionChange?: (keys: "all" | Set<Key>) => void;
+  /** Currently expanded keys (controlled). */
+  expandedKeys?: Iterable<Key>;
+  /** Default expanded keys (uncontrolled). */
+  defaultExpandedKeys?: Iterable<Key>;
+  /** Handler for expansion changes. */
+  onExpandedChange?: (keys: Set<Key>) => void;
 }
 /**
  * Item representation for building tree collections.
  */
 export interface TreeItemData<T = unknown> {
-    /** Unique key for this item. */
-    key: Key;
-    /** The data value for this item. */
-    value: T;
-    /** Text content for accessibility and search. */
-    textValue?: string;
-    /** Child items (makes this item expandable). */
-    children?: TreeItemData<T>[];
-    /** Whether this item is disabled. */
-    isDisabled?: boolean;
+  /** Unique key for this item. */
+  key: Key;
+  /** The data value for this item. */
+  value: T;
+  /** Text content for accessibility and search. */
+  textValue?: string;
+  /** Child items (makes this item expandable). */
+  children?: TreeItemData<T>[];
+  /** Whether this item is disabled. */
+  isDisabled?: boolean;
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.ts.map

package/src/tree/types.ts

@@ -3,8 +3,8 @@
  * Based on @react-stately/tree.
  */
 
-import type { Key, FocusStrategy } from '../collections/types';
-import type { GridNode, GridCollection } from '../grid/types';
+import type { Key, FocusStrategy } from "../collections/types";
+import type { GridNode, GridCollection } from "../grid/types";
 
 /**
  * Represents a node in a tree collection.
@@ -29,7 +29,10 @@ export interface TreeNode<T = unknown> extends GridNode<T> {
  * A collection of tree nodes with tree-specific navigation.
  * Only includes visible nodes (respects expanded state).
  */
-export interface TreeCollection<T = unknown> extends Omit<GridCollection<T>, 'rows' | 'columns' | 'headerRows' | 'columnCount' | 'getCell'> {
+export interface TreeCollection<T = unknown> extends Omit<
+  GridCollection<T>,
+  "rows" | "columns" | "headerRows" | "columnCount" | "getCell"
+> {
   /** All visible rows in the tree (respects expanded state). */
   readonly rows: TreeNode<T>[];
   /** Number of visible rows. */
@@ -89,9 +92,11 @@ export interface TreeState<T, C extends TreeCollection<T> = TreeCollection<T>> {
   /** Whether the tree is focused. */
   readonly isFocused: boolean;
   /** The selection mode. */
-  readonly selectionMode: 'none' | 'single' | 'multiple';
+  readonly selectionMode: "none" | "single" | "multiple";
+  /** How selection behaves when pressing an item. */
+  readonly selectionBehavior: "toggle" | "replace";
   /** The currently selected keys. */
-  readonly selectedKeys: 'all' | Set<Key>;
+  readonly selectedKeys: "all" | Set<Key>;
 
   /** Check if a key is selected. */
   isSelected(key: Key): boolean;
@@ -136,19 +141,19 @@ export interface TreeStateOptions<T, C extends TreeCollection<T> = TreeCollectio
   /** Keys of disabled items. */
   disabledKeys?: Iterable<Key>;
   /** Disabled behavior: 'selection' only or 'all' interactions. */
-  disabledBehavior?: 'selection' | 'all';
+  disabledBehavior?: "selection" | "all";
   /** Selection mode. */
-  selectionMode?: 'none' | 'single' | 'multiple';
+  selectionMode?: "none" | "single" | "multiple";
   /** Selection behavior. */
-  selectionBehavior?: 'toggle' | 'replace';
+  selectionBehavior?: "toggle" | "replace";
   /** Whether empty selection is disallowed. */
   disallowEmptySelection?: boolean;
   /** Currently selected keys (controlled). */
-  selectedKeys?: 'all' | Iterable<Key>;
+  selectedKeys?: "all" | Iterable<Key>;
   /** Default selected keys (uncontrolled). */
-  defaultSelectedKeys?: 'all' | Iterable<Key>;
+  defaultSelectedKeys?: "all" | Iterable<Key>;
   /** Handler for selection changes. */
-  onSelectionChange?: (keys: 'all' | Set<Key>) => void;
+  onSelectionChange?: (keys: "all" | Set<Key>) => void;
   /** Currently expanded keys (controlled). */
   expandedKeys?: Iterable<Key>;
   /** Default expanded keys (uncontrolled). */
@@ -162,13 +167,17 @@ export interface TreeStateOptions<T, C extends TreeCollection<T> = TreeCollectio
  */
 export interface TreeItemData<T = unknown> {
   /** Unique key for this item. */
-  key: Key;
+  key?: Key;
+  /** S2/React Aria-compatible unique id alias. */
+  id?: Key;
   /** The data value for this item. */
-  value: T;
+  value?: T;
   /** Text content for accessibility and search. */
   textValue?: string;
   /** Child items (makes this item expandable). */
   children?: TreeItemData<T>[];
+  /** Whether this item has children that may not be loaded yet. */
+  hasChildItems?: boolean;
   /** Whether this item is disabled. */
   isDisabled?: boolean;
 }

package/src/utils/index.d.ts

@@ -1,2 +1,2 @@
-export { access, isAccessor, type MaybeAccessor, type MaybeAccessorValue } from './reactivity';
-//# sourceMappingURL=index.d.ts.map
+export { access, isAccessor, type MaybeAccessor, type MaybeAccessorValue } from "./reactivity";
+//# sourceMappingURL=index.d.ts.map