@proyecto-viviana/solid-stately 0.3.0 → 0.4.0

package/src/selection/createMultipleSelectionState.ts

@@ -0,0 +1,247 @@
+/**
+ * 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 { createSignal, createMemo, createComputed, untrack, type Accessor } from "solid-js";
+import { access, type MaybeAccessor } from "../utils";
+import type { SelectionStateProps } from "../collections/createSelectionState";
+import type {
+  DisabledBehavior,
+  FocusStrategy,
+  Key,
+  Selection,
+  SelectionBehavior,
+  SelectionMode,
+} from "../collections/types";
+import { Selection as SelectionClass } from "./Selection";
+
+/**
+ * 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;
+}
+
+function equalSets(setA: Set<Key>, setB: Set<Key>): boolean {
+  if (setA.size !== setB.size) {
+    return false;
+  }
+
+  for (const item of setA) {
+    if (!setB.has(item)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function convertSelection(
+  selection: "all" | Iterable<Key> | null | undefined,
+  defaultValue: Selection,
+): Selection;
+function convertSelection(
+  selection: "all" | Iterable<Key> | null | undefined,
+): Selection | undefined;
+function convertSelection(
+  selection: "all" | Iterable<Key> | null | undefined,
+  defaultValue?: Selection,
+): Selection | undefined {
+  if (!selection) {
+    return defaultValue;
+  }
+
+  return selection === "all" ? "all" : new SelectionClass(selection);
+}
+
+/**
+ * Manages raw state for multiple selection and focus in a collection.
+ */
+export function createMultipleSelectionState(
+  props: MaybeAccessor<SelectionStateProps> = {},
+): MultipleSelectionState {
+  const getProps = () => access(props);
+
+  // Focus is a plain signal in Solid; upstream needs a ref + state pair only
+  // because React requires both a synchronous read and a re-render trigger.
+  const [isFocused, setIsFocused] = createSignal(false);
+  const [focusedKey, setFocusedKeySignal] = createSignal<Key | null>(null);
+  const [childFocusStrategy, setChildFocusStrategy] = createSignal<FocusStrategy | null>(null);
+
+  const defaultSelectedKeys = convertSelection(
+    getProps().defaultSelectedKeys,
+    new SelectionClass(),
+  );
+  const [uncontrolledSelectedKeys, setUncontrolledSelectedKeys] =
+    createSignal<Selection>(defaultSelectedKeys);
+
+  const selectedKeys = createMemo<Selection>(() => {
+    const p = getProps();
+    if (p.selectedKeys !== undefined) {
+      return convertSelection(p.selectedKeys, new SelectionClass());
+    }
+    return uncontrolledSelectedKeys();
+  });
+
+  // Selection behavior is seeded from the prop but kept in internal state so
+  // that `setSelectionBehavior` (e.g. the long-press-to-select touch flow) can
+  // override it. Two reactive rules mirror upstream's render-time logic.
+  const selectionBehaviorProp = (): SelectionBehavior => getProps().selectionBehavior ?? "toggle";
+
+  const [selectionBehavior, setSelectionBehaviorState] =
+    createSignal<SelectionBehavior>(selectionBehaviorProp());
+
+  // If the selectionBehavior prop is 'replace' but the current state is 'toggle'
+  // (e.g. due to a long press to enter selection mode on touch) and the
+  // selection becomes empty, reset the behavior back to 'replace'.
+  createComputed(() => {
+    const keys = selectedKeys();
+    if (
+      selectionBehaviorProp() === "replace" &&
+      untrack(selectionBehavior) === "toggle" &&
+      typeof keys === "object" &&
+      keys.size === 0
+    ) {
+      setSelectionBehaviorState("replace");
+    }
+  });
+
+  // If the selectionBehavior prop changes, sync it into state.
+  let lastSelectionBehavior = selectionBehaviorProp();
+  createComputed(() => {
+    const prop = selectionBehaviorProp();
+    if (prop !== lastSelectionBehavior) {
+      setSelectionBehaviorState(prop);
+      lastSelectionBehavior = prop;
+    }
+  });
+
+  const disabledKeys = createMemo<Set<Key>>(() => {
+    const keys = getProps().disabledKeys;
+    return keys ? new Set<Key>(keys) : new Set<Key>();
+  });
+
+  let lastSelectionEvent: Selection | null = null;
+
+  const emitSelectionEvent = (keys: Selection) => {
+    lastSelectionEvent = keys;
+    getProps().onSelectionChange?.(keys);
+  };
+
+  const setSelectedKeys = (keys: Selection) => {
+    const p = getProps();
+    const current = selectedKeys();
+    const shouldUpdate =
+      p.allowDuplicateSelectionEvents ||
+      keys === "all" ||
+      current === "all" ||
+      !equalSets(keys, current);
+
+    if (!shouldUpdate) {
+      return;
+    }
+
+    // Uncontrolled: store internally. Controlled: only notify.
+    if (p.selectedKeys === undefined) {
+      setUncontrolledSelectedKeys(keys);
+    }
+    emitSelectionEvent(keys);
+  };
+
+  const emitDuplicateSelectionEvent = (keys?: Selection) => {
+    const eventKeys = keys ?? lastSelectionEvent;
+    if (eventKeys == null) {
+      return;
+    }
+    emitSelectionEvent(eventKeys);
+  };
+
+  return {
+    get selectionMode() {
+      return getProps().selectionMode ?? "none";
+    },
+    get selectionBehavior() {
+      return selectionBehavior();
+    },
+    setSelectionBehavior(behavior: SelectionBehavior) {
+      setSelectionBehaviorState(behavior);
+    },
+    get disallowEmptySelection() {
+      return getProps().disallowEmptySelection ?? false;
+    },
+    get isFocused() {
+      return isFocused();
+    },
+    setFocused(f: boolean) {
+      setIsFocused(f);
+    },
+    get focusedKey() {
+      return focusedKey();
+    },
+    get childFocusStrategy() {
+      return childFocusStrategy();
+    },
+    setFocusedKey(key: Key | null, strategy: FocusStrategy = "first") {
+      setFocusedKeySignal(key);
+      setChildFocusStrategy(strategy);
+    },
+    get selectedKeys() {
+      return selectedKeys();
+    },
+    get lastSelectionEvent() {
+      return lastSelectionEvent;
+    },
+    setSelectedKeys,
+    emitDuplicateSelectionEvent,
+    get disabledKeys() {
+      return disabledKeys();
+    },
+    get disabledBehavior() {
+      return getProps().disabledBehavior ?? "all";
+    },
+  };
+}
+
+// Re-export the accessor type for convenience where a reactive read is wanted.
+export type { Accessor };

package/src/selection/index.ts

@@ -11,6 +11,12 @@ export {
   type SelectionState,
 } from "../collections/createSelectionState";
 
+export {
+  SelectionManager,
+  type SelectionManagerOptions,
+  type LayoutDelegate,
+} from "./SelectionManager";
+
 export type {
   Key,
   Selection,

package/src/table/TableCollection.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";
@@ -24,6 +30,10 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
   private _keyMap: Map<Key, GridNode<T>> = new Map();
   private _rowHeaderColumnKeys: Set<Key>;
   private _size: number = 0;
+  /** Visible rows in DFS order. Drives size, navigation, iteration and the `rows` list. */
+  private _flattenedRows: GridNode<T>[] = [];
+  private _treeColumn: Key | null = null;
+  private _userColumnCount: number = 0;
 
   constructor(options: TableCollectionOptions<T>) {
     const {
@@ -33,8 +43,12 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
       getTextValue,
       showSelectionCheckboxes = false,
       rowHeaderColumnKeys,
+      expandedKeys,
     } = options;
 
+    // Passing `expandedKeys` (even an empty set) selects tree-grid mode.
+    const isTreeGrid = expandedKeys !== undefined;
+
     this._columns = this.buildColumns(columns, showSelectionCheckboxes);
 
     this._rowHeaderColumnKeys = rowHeaderColumnKeys ?? this.getDefaultRowHeaderColumnKeys();
@@ -55,8 +69,25 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
       this._keyMap.set("header", this._head);
     }
 
-    const bodyRows = this.buildRows(rows, getKey, getTextValue);
-    this._size = bodyRows.length;
+    let bodyChildren: GridNode<T>[];
+    if (isTreeGrid) {
+      const built = this.buildTreeRows(rows, expandedKeys, getKey, getTextValue);
+      bodyChildren = built.topLevelRows;
+      this._flattenedRows = built.flattenedRows;
+      this._userColumnCount = this.countLeafColumns();
+      this._treeColumn =
+        options.treeColumn !== undefined
+          ? options.treeColumn
+          : (this._rowHeaderColumnKeys.values().next().value ?? null);
+    } else {
+      const bodyRows = this.buildRows(rows, getKey, getTextValue);
+      bodyChildren = bodyRows;
+      this._flattenedRows = bodyRows;
+      this._userColumnCount = this.countLeafColumns();
+      this._treeColumn = null;
+    }
+
+    this._size = this._flattenedRows.length;
 
     this._body = {
       type: "item" as GridNodeType,
@@ -64,13 +95,17 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
       index: this._headerRows.length,
       level: 0,
       hasChildNodes: true,
-      childNodes: bodyRows,
+      // The body's children retain the full tree structure (top-level rows with their
+      // child rows nested inside) so sibling-based aria-posinset/aria-setsize work; the
+      // flattened visible list lives in `_flattenedRows`. For a flat table these are the
+      // same array.
+      childNodes: bodyChildren,
       value: null,
       textValue: "",
     };
     this._keyMap.set("body", this._body);
 
-    this._rows = [...this._headerRows, ...bodyRows];
+    this._rows = [...this._headerRows, ...this._flattenedRows];
   }
 
   private buildColumns(
@@ -158,6 +193,23 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
     return new Set();
   }
 
+  /** Counts the leaf columns supplied by the user (excludes the selection column). */
+  private countLeafColumns(): number {
+    let count = 0;
+    const visit = (col: GridNode<T>) => {
+      if (col.key === "__selection__") {
+        return;
+      }
+      if (col.childNodes.length > 0) {
+        col.childNodes.forEach(visit);
+      } else {
+        count++;
+      }
+    };
+    this._columns.forEach(visit);
+    return count;
+  }
+
   private buildHeaderRows(): GridNode<T>[] {
     if (this._columns.length === 0) {
       return [];
@@ -194,6 +246,47 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
     return [headerRow];
   }
 
+  /**
+   * 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(
+    rowKey: Key,
+    value: T,
+    rowLevel: number,
+    getTextValue?: (item: T, column: ColumnDefinition<T>) => string,
+  ): GridNode<T>[] {
+    return this._columns.map((col, colIndex) => {
+      const cellKey = `${rowKey}-${col.key}`;
+      const columnDefinition =
+        (col.props?.columnDefinition as ColumnDefinition<T> | undefined) ??
+        ({ key: col.key } as ColumnDefinition<T>);
+      const cellTextValue =
+        col.key === "__selection__"
+          ? "Selection"
+          : getTextValue
+            ? getTextValue(value, columnDefinition)
+            : String((value as Record<string, unknown>)?.[String(col.key)] ?? "");
+
+      const cell: GridNode<T> = {
+        type: this._rowHeaderColumnKeys.has(col.key)
+          ? ("rowheader" as GridNodeType)
+          : ("cell" as GridNodeType),
+        key: cellKey,
+        index: colIndex,
+        column: colIndex,
+        level: rowLevel + 1,
+        hasChildNodes: false,
+        childNodes: [],
+        value,
+        textValue: cellTextValue,
+        parentKey: rowKey,
+      };
+
+      return cell;
+    });
+  }
+
   private buildRows(
     rows: RowDefinition<T>[] | T[],
     getKey?: (item: T) => Key,
@@ -214,36 +307,8 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
           ? ((row as Record<string, unknown>).textValue as string)
           : undefined;
 
-      const cells: GridNode<T>[] = this._columns.map((col, colIndex) => {
-        const cellKey = `${key}-${col.key}`;
-        const columnDefinition =
-          (col.props?.columnDefinition as ColumnDefinition<T> | undefined) ??
-          ({ key: col.key } as ColumnDefinition<T>);
-        const cellTextValue =
-          col.key === "__selection__"
-            ? "Selection"
-            : getTextValue
-              ? getTextValue(value, columnDefinition)
-              : String((value as Record<string, unknown>)?.[String(col.key)] ?? "");
-
-        const cell: GridNode<T> = {
-          type: this._rowHeaderColumnKeys.has(col.key)
-            ? ("rowheader" as GridNodeType)
-            : ("cell" as GridNodeType),
-          key: cellKey,
-          index: colIndex,
-          column: colIndex,
-          level: 1,
-          hasChildNodes: false,
-          childNodes: [],
-          value,
-          textValue: cellTextValue,
-          parentKey: key,
-        };
-
-        this._keyMap.set(cellKey, cell);
-        return cell;
-      });
+      const cells = this.buildCells(key, value as T, 0, getTextValue);
+      cells.forEach((cell) => this._keyMap.set(cell.key, cell));
 
       const rowNode: GridNode<T> = {
         type: "item" as GridNodeType,
@@ -264,6 +329,97 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
     return result;
   }
 
+  /**
+   * 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(
+    rows: RowDefinition<T>[] | T[],
+    expandedKeys: "all" | Set<Key>,
+    getKey?: (item: T) => Key,
+    getTextValue?: (item: T, column: ColumnDefinition<T>) => string,
+  ): { topLevelRows: GridNode<T>[]; flattenedRows: GridNode<T>[] } {
+    const isExpanded = (key: Key): boolean => expandedKeys === "all" || expandedKeys.has(key);
+
+    // Build the full tree structure without touching the key map. `index` is the row's
+    // position among its same-level siblings, so aria-posinset/aria-setsize read directly.
+    const buildRowNode = (
+      row: RowDefinition<T> | T,
+      level: number,
+      parentKey: Key | null,
+      indexAmongSiblings: number,
+    ): GridNode<T> => {
+      const isRowDef = this.isRowDefinition(row);
+      const key = isRowDef ? row.key : (getKey?.(row as T) ?? indexAmongSiblings);
+      const value = (isRowDef ? row.value : (row as T)) as T;
+      const textValue = isRowDef
+        ? row.textValue
+        : typeof (row as Record<string, unknown>)?.textValue === "string"
+          ? ((row as Record<string, unknown>).textValue as string)
+          : undefined;
+
+      const cells = this.buildCells(key, value, level, getTextValue);
+
+      const childRowDefs = isRowDef ? (row.childRows ?? []) : [];
+      const hasChildRows = childRowDefs.length > 0 || (isRowDef && !!row.hasChildRows);
+
+      const childRowNodes = childRowDefs.map((child, childIdx) =>
+        buildRowNode(child, level + 1, key, childIdx),
+      );
+
+      const childNodes = [...cells, ...childRowNodes];
+      const rowNode: GridNode<T> = {
+        type: "item" as GridNodeType,
+        key,
+        index: indexAmongSiblings,
+        level,
+        parentKey,
+        hasChildNodes: true,
+        childNodes,
+        value,
+        textValue: textValue ?? cells.map((c) => c.textValue).join(" "),
+        isExpandable: hasChildRows,
+        isExpanded: hasChildRows && isExpanded(key),
+        firstChildKey: childNodes[0]?.key ?? null,
+        lastChildKey: childNodes[childNodes.length - 1]?.key ?? null,
+      };
+
+      return rowNode;
+    };
+
+    const topLevelRows = rows.map((row, i) => buildRowNode(row, 0, "body", i));
+
+    // Flatten the visible rows (DFS). A row is visited iff every ancestor is expanded;
+    // visiting a row registers it and its cells, then descends into its child rows only
+    // when the row itself is expanded.
+    const flattenedRows: GridNode<T>[] = [];
+    const rowIndexOffset = this._headerRows.length;
+    const visit = (node: GridNode<T>) => {
+      node.rowIndex = rowIndexOffset + flattenedRows.length;
+      flattenedRows.push(node);
+      this._keyMap.set(node.key, node);
+      for (const child of node.childNodes) {
+        if (child.type !== "item") {
+          this._keyMap.set(child.key, child);
+        }
+      }
+      if (isExpanded(node.key)) {
+        for (const child of node.childNodes) {
+          if (child.type === "item") {
+            visit(child);
+          }
+        }
+      }
+    };
+    for (const node of topLevelRows) {
+      visit(node);
+    }
+
+    return { topLevelRows, flattenedRows };
+  }
+
   private isRowDefinition(row: unknown): row is RowDefinition<T> {
     return typeof row === "object" && row !== null && "key" in row && "value" in row;
   }
@@ -304,6 +460,21 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
     return this._rowHeaderColumnKeys;
   }
 
+  /** The key of the column that renders the tree-grid affordance, or `null` for a flat table. */
+  get treeColumn(): Key | null {
+    return this._treeColumn;
+  }
+
+  /** The number of leaf columns provided by the user (excludes the selection column). */
+  get userColumnCount(): number {
+    return this._userColumnCount;
+  }
+
+  /** The key map of all present nodes (visible rows, their cells, columns and the body). */
+  get keyMap(): Map<Key, GridNode<T>> {
+    return this._keyMap;
+  }
+
   getKeys(): Iterable<Key> {
     return this._keyMap.keys();
   }
@@ -313,11 +484,10 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
   }
 
   at(index: number): GridNode<T> | null {
-    const bodyRows = this._body.childNodes;
-    if (index < 0 || index >= bodyRows.length) {
+    if (index < 0 || index >= this._flattenedRows.length) {
       return null;
     }
-    return bodyRows[index];
+    return this._flattenedRows[index];
   }
 
   getChildren(key: Key): Iterable<GridNode<T>> {
@@ -336,12 +506,12 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
   }
 
   getFirstKey(): Key | null {
-    const bodyRows = this._body.childNodes;
+    const bodyRows = this._flattenedRows;
     return bodyRows.length > 0 ? bodyRows[0].key : null;
   }
 
   getLastKey(): Key | null {
-    const bodyRows = this._body.childNodes;
+    const bodyRows = this._flattenedRows;
     return bodyRows.length > 0 ? bodyRows[bodyRows.length - 1].key : null;
   }
 
@@ -349,7 +519,7 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
     const node = this._keyMap.get(key);
     if (!node) return null;
 
-    const bodyRows = this._body.childNodes;
+    const bodyRows = this._flattenedRows;
     const index = bodyRows.findIndex((r) => r.key === key);
     if (index > 0) {
       return bodyRows[index - 1].key;
@@ -361,7 +531,7 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
     const node = this._keyMap.get(key);
     if (!node) return null;
 
-    const bodyRows = this._body.childNodes;
+    const bodyRows = this._flattenedRows;
     const index = bodyRows.findIndex((r) => r.key === key);
     if (index >= 0 && index < bodyRows.length - 1) {
       return bodyRows[index + 1].key;
@@ -370,8 +540,8 @@ export class TableCollection<T = unknown> implements ITableCollection<T> {
   }
 
   *[Symbol.iterator](): Iterator<GridNode<T>> {
-    // Only iterate body rows, not header rows
-    for (const row of this._body.childNodes) {
+    // Only iterate visible body rows, not header rows.
+    for (const row of this._flattenedRows) {
       yield row;
     }
   }

package/src/table/createTableState.ts

@@ -33,6 +33,7 @@ export function createTableState<
   const gridState = createGridState<T, C>(() => ({
     collection: getOptions().collection,
     disabledKeys: getOptions().disabledKeys,
+    disabledBehavior: getOptions().disabledBehavior,
     focusMode: getOptions().focusMode,
     selectionMode: getOptions().selectionMode,
     selectionBehavior: getOptions().selectionBehavior,
@@ -83,6 +84,9 @@ export function createTableState<
     get disabledKeys() {
       return gridState.disabledKeys;
     },
+    get disabledBehavior() {
+      return gridState.disabledBehavior;
+    },
     get isKeyboardNavigationDisabled() {
       return gridState.isKeyboardNavigationDisabled;
     },
@@ -101,6 +105,9 @@ export function createTableState<
     get selectionBehavior() {
       return gridState.selectionBehavior;
     },
+    get disallowEmptySelection() {
+      return gridState.disallowEmptySelection;
+    },
     get selectedKeys() {
       return gridState.selectedKeys;
     },
@@ -112,6 +119,8 @@ export function createTableState<
     setFocused: gridState.setFocused,
     toggleSelection: gridState.toggleSelection,
     replaceSelection: gridState.replaceSelection,
+    setSelectionBehavior: gridState.setSelectionBehavior,
+    setSelectedKeys: gridState.setSelectedKeys,
     extendSelection: gridState.extendSelection,
     selectAll: gridState.selectAll,
     clearSelection: gridState.clearSelection,
@@ -126,5 +135,16 @@ export function createTableState<
       return sortDescriptor();
     },
     sort,
+
+    // A plain table has no expandable rows.
+    get expandedKeys(): "all" | Set<Key> {
+      return EMPTY_EXPANDED_KEYS;
+    },
+    get treeColumn(): Key | null {
+      return getOptions().collection.treeColumn ?? null;
+    },
+    toggleKey: () => {},
   };
 }
+
+const EMPTY_EXPANDED_KEYS: Set<Key> = new Set();