@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.0

package/data/list-data.jsx

@@ -0,0 +1,210 @@
+// Ported from @react-stately/data (useListData.ts), Apache-2.0, © Adobe.
+//
+// Rivet:
+// - `useListData` → `createListData` (wave-2 decision 7; docs map the RAC name). Call it once in a
+//   component body (or module scope for shared data); it returns a plain object of signals +
+//   arrow functions, so a resumed page shares it between handlers and bindings.
+// - Reactive members: `items` is a computed accessor (`list.items()`, filtered by `filterText`),
+//   `selectedKeys` is a two-way `Signal<Selection>` (pass it straight to a collection's
+//   `selectedKeys`; `setSelectedKeys` writes the same signal), `filterText` an accessor. React's
+//   `{...state}` snapshot is `listDataState(list)`.
+// - `.tsx` without JSX: resume-compiled so the arrow functions of the returned object are R2 symbols
+//   (a `.ts` module's closures would not serialize). `filter` / `getKey` options must be inline
+//   arrows or local functions (they are captured).
+// - The state is region state (`_regionState`): a re-created region keeps its list.
+import { batch, computed, signal, untrack, _regionState } from "@rivetjs/reactivity";
+/** Snapshot of the list state (react-stately's `state`; reads the signals). */
+export function listStoreState(store) {
+    return { items: store.rawItems(), selectedKeys: store.selectedKeys(), filterText: store.filterTextSignal() };
+}
+/** Applies a reducer step to the store: writes back the fields that changed (one batch). */
+export function dispatchList(store, updater) {
+    batch(() => {
+        const state = untrack(() => listStoreState(store));
+        const next = updater(state);
+        if (next === state)
+            return;
+        if (next.items !== state.items)
+            store.rawItems.set(next.items);
+        if (next.selectedKeys !== state.selectedKeys)
+            store.selectedKeys.set(next.selectedKeys);
+        if (next.filterText !== state.filterText)
+            store.filterTextSignal.set(next.filterText);
+    });
+}
+/** The list operations over a dispatch function (react-stately `createListActions`). */
+export function createListActions(opts, dispatch) {
+    const { cursor } = opts;
+    const getKey = opts.getKey;
+    return {
+        setSelectedKeys: (selectedKeys) => dispatch((state) => ({ ...state, selectedKeys })),
+        addKeysToSelection: (selectedKeys) => dispatch((state) => {
+            if (state.selectedKeys === "all")
+                return state;
+            if (selectedKeys === "all")
+                return { ...state, selectedKeys: "all" };
+            return { ...state, selectedKeys: new Set([...state.selectedKeys, ...selectedKeys]) };
+        }),
+        removeKeysFromSelection: (selectedKeys) => dispatch((state) => {
+            if (selectedKeys === "all")
+                return { ...state, selectedKeys: new Set() };
+            const selection = state.selectedKeys === "all" ? new Set(state.items.map(getKey)) : new Set(state.selectedKeys);
+            for (const key of selectedKeys)
+                selection.delete(key);
+            return { ...state, selectedKeys: selection };
+        }),
+        setFilterText: (filterText) => dispatch((state) => ({ ...state, filterText })),
+        insert: (index, ...values) => dispatch((state) => insert(state, index, ...values)),
+        insertBefore: (key, ...values) => dispatch((state) => {
+            let index = state.items.findIndex((item) => getKey(item) === key);
+            if (index === -1) {
+                if (state.items.length === 0)
+                    index = 0;
+                else
+                    return state;
+            }
+            return insert(state, index, ...values);
+        }),
+        insertAfter: (key, ...values) => dispatch((state) => {
+            let index = state.items.findIndex((item) => getKey(item) === key);
+            if (index === -1) {
+                if (state.items.length === 0)
+                    index = 0;
+                else
+                    return state;
+            }
+            return insert(state, index + 1, ...values);
+        }),
+        prepend: (...values) => dispatch((state) => insert(state, 0, ...values)),
+        append: (...values) => dispatch((state) => insert(state, state.items.length, ...values)),
+        remove: (...keys) => dispatch((state) => {
+            const keySet = new Set(keys);
+            const items = state.items.filter((item) => !keySet.has(getKey(item)));
+            let selection = "all";
+            if (state.selectedKeys !== "all") {
+                selection = new Set(state.selectedKeys);
+                for (const key of keys)
+                    selection.delete(key);
+            }
+            if ((cursor ? cursor() : undefined) == null && items.length === 0)
+                selection = new Set();
+            return { ...state, items, selectedKeys: selection };
+        }),
+        removeSelectedItems: () => dispatch((state) => {
+            if (state.selectedKeys === "all")
+                return { ...state, items: [], selectedKeys: new Set() };
+            const selectedKeys = state.selectedKeys;
+            const items = state.items.filter((item) => !selectedKeys.has(getKey(item)));
+            return { ...state, items, selectedKeys: new Set() };
+        }),
+        move: (key, toIndex) => dispatch((state) => {
+            const index = state.items.findIndex((item) => getKey(item) === key);
+            if (index === -1)
+                return state;
+            const copy = state.items.slice();
+            const [item] = copy.splice(index, 1);
+            copy.splice(toIndex, 0, item);
+            return { ...state, items: copy };
+        }),
+        moveBefore: (key, keys) => dispatch((state) => {
+            const toIndex = state.items.findIndex((item) => getKey(item) === key);
+            if (toIndex === -1)
+                return state;
+            // Find indices of keys to move. Sort them so that the order in the list is retained.
+            const keyArray = Array.isArray(keys) ? keys : [...keys];
+            const indices = keyArray.map((k) => state.items.findIndex((item) => getKey(item) === k)).sort((a, b) => a - b);
+            return move(state, indices, toIndex);
+        }),
+        moveAfter: (key, keys) => dispatch((state) => {
+            const toIndex = state.items.findIndex((item) => getKey(item) === key);
+            if (toIndex === -1)
+                return state;
+            const keyArray = Array.isArray(keys) ? keys : [...keys];
+            const indices = keyArray.map((k) => state.items.findIndex((item) => getKey(item) === k)).sort((a, b) => a - b);
+            return move(state, indices, toIndex + 1);
+        }),
+        update: (key, newValue) => dispatch((state) => {
+            const index = state.items.findIndex((item) => getKey(item) === key);
+            if (index === -1)
+                return state;
+            const updatedValue = typeof newValue === "function" ? newValue(state.items[index]) : newValue;
+            return { ...state, items: [...state.items.slice(0, index), updatedValue, ...state.items.slice(index + 1)] };
+        }),
+    };
+}
+function insert(state, index, ...values) {
+    return { ...state, items: [...state.items.slice(0, index), ...values, ...state.items.slice(index)] };
+}
+function move(state, indices, toIndex) {
+    // Shift the target down by the number of items being moved from before the target.
+    toIndex -= indices.filter((index) => index < toIndex).length;
+    const moves = indices.map((from) => ({ from, to: toIndex++ }));
+    // Shift later from indices down if they have a larger index.
+    for (let i = 0; i < moves.length; i++) {
+        const a = moves[i].from;
+        for (let j = i; j < moves.length; j++) {
+            const b = moves[j].from;
+            if (b > a)
+                moves[j].from--;
+        }
+    }
+    // Interleave the moves so they can be applied one by one rather than all at once.
+    for (let i = 0; i < moves.length; i++) {
+        const a = moves[i];
+        for (let j = moves.length - 1; j > i; j--) {
+            const b = moves[j];
+            if (b.from < a.to)
+                a.to++;
+            else
+                b.from++;
+        }
+    }
+    const copy = state.items.slice();
+    for (const m of moves) {
+        const [item] = copy.splice(m.from, 1);
+        copy.splice(m.to, 0, item);
+    }
+    return { ...state, items: copy };
+}
+/** Default item key: `item.id ?? item.key` (react-stately). */
+export const defaultGetKey = (item) => item.id ?? item.key;
+/**
+ * Manages state for an immutable list data structure, and provides convenience methods to update
+ * the data over time (react-stately `useListData`).
+ */
+export function createListData(options = {}) {
+    return _regionState(() => {
+        const { initialItems = [], initialSelectedKeys, filter, initialFilterText = "" } = options;
+        // Resumable: a module-level default is not a serializable capture; the fallback is an object-literal arrow (a resume symbol).
+        const userKey = options.getKey;
+        const keys = { get: (item) => (userKey ? userKey(item) : defaultGetKey(item)) };
+        const getKey = keys.get;
+        // Store both items and filteredItems so we can go back to the unfiltered list.
+        const store = {
+            rawItems: signal(initialItems),
+            selectedKeys: signal(initialSelectedKeys === "all" ? "all" : new Set(initialSelectedKeys || [])),
+            filterTextSignal: signal(initialFilterText),
+        };
+        const items = computed(() => {
+            const all = store.rawItems();
+            if (!filter)
+                return all;
+            const text = store.filterTextSignal();
+            return all.filter((item) => filter(item, text));
+        });
+        // Resumable: an arrow only passed as an argument is not a resume symbol, so it lives in an object literal
+        // (whose arrow properties are) — the actions capture it.
+        const io = { dispatch: (updater) => dispatchList(store, updater) };
+        return {
+            items,
+            selectedKeys: store.selectedKeys,
+            filterText: store.filterTextSignal,
+            ...createListActions({ getKey }, io.dispatch),
+            getItem: (key) => store.rawItems().find((item) => getKey(item) === key),
+        };
+    });
+}
+/** react-stately's `{...state}` snapshot of a list (items filtered). Reads state. */
+export function listDataState(list) {
+    return { items: list.items(), selectedKeys: list.selectedKeys(), filterText: list.filterText() };
+}

package/data/tree-data.d.ts

@@ -0,0 +1,59 @@
+import { type Signal } from "@rivetjs/reactivity";
+import type { Key } from "../collections/types.js";
+export interface TreeOptions<T extends object> {
+    /** Initial root items in the tree. */
+    initialItems?: T[] | undefined;
+    /** The keys for the initially selected items. */
+    initialSelectedKeys?: Iterable<Key> | undefined;
+    /** A function that returns a unique key for an item object. Default `item.id ?? item.key`. */
+    getKey?: ((item: T) => Key) | undefined;
+    /** A function that returns the children for an item object. Default `item.children`. */
+    getChildren?: ((item: T) => T[]) | undefined;
+}
+export interface TreeNode<T extends object> {
+    /** A unique key for the tree node. */
+    key: Key;
+    /** The key of the parent node. */
+    parentKey?: Key | null;
+    /** The value object for the tree node. */
+    value: T;
+    /** Children of the tree node. */
+    children: TreeNode<T>[] | null;
+}
+export interface TreeData<T extends object> {
+    /** The root nodes in the tree. Reads state. */
+    readonly items: () => TreeNode<T>[];
+    /** The keys of the currently selected items in the tree (two-way signal). */
+    readonly selectedKeys: Signal<Set<Key>>;
+    /** Sets the selected keys. */
+    setSelectedKeys(keys: Set<Key>): void;
+    /** Gets a node from the tree by key. */
+    getItem(key: Key): TreeNode<T> | undefined;
+    /** Inserts an item into a parent node as a child (`parentKey` null: the root). */
+    insert(parentKey: Key | null, index: number, ...values: T[]): void;
+    /** Inserts items before the item at the given key. */
+    insertBefore(key: Key, ...values: T[]): void;
+    /** Inserts items after the item at the given key. */
+    insertAfter(key: Key, ...values: T[]): void;
+    /** Appends an item into a parent node as a child. */
+    append(parentKey: Key | null, ...values: T[]): void;
+    /** Prepends an item into a parent node as a child. */
+    prepend(parentKey: Key | null, ...value: T[]): void;
+    /** Removes items from the tree by their keys. */
+    remove(...keys: Key[]): void;
+    /** Removes all items from the tree that are currently in the set of selected items. */
+    removeSelectedItems(): void;
+    /** Moves an item within the tree. */
+    move(key: Key, toParentKey: Key | null, index: number): void;
+    /** Moves one or more items before a given key. */
+    moveBefore(key: Key, keys: Iterable<Key>): void;
+    /** Moves one or more items after a given key. */
+    moveAfter(key: Key, keys: Iterable<Key>): void;
+    /** Updates an item in the tree. */
+    update(key: Key, newValue: T): void;
+}
+/**
+ * Manages state for an immutable tree data structure, and provides convenience methods to update
+ * the data over time (react-stately `useTreeData`).
+ */
+export declare function createTreeData<T extends object>(options?: TreeOptions<T>): TreeData<T>;

package/data/tree-data.jsx

@@ -0,0 +1,278 @@
+// Ported from @react-stately/data (useTreeData.ts), Apache-2.0, © Adobe.
+//
+// Rivet:
+// - `useTreeData` → `createTreeData` (wave-2 decision 7). Returns a plain object of signals + arrow
+//   functions (resumable, `.tsx` so the arrows are R2 symbols); `items` is an accessor of the root
+//   nodes (`tree.items()`), `selectedKeys` a two-way `Signal<Set<Key>>`.
+// - State = one signal of `{ items, nodeMap }` (plain objects + a Map: serializable) + the selection
+//   signal; region state (`_regionState`).
+// - react-stately's methods read the tree of the current render (`nodeMap`, `items`, `selectedKeys`
+//   closures); here they read the signals when called, which is the same between renders.
+import { batch, signal, untrack, _regionState } from "@rivetjs/reactivity";
+function buildTree(getKey, getChildren, initialItems = [], map, parentKey) {
+    if (initialItems == null)
+        initialItems = [];
+    return {
+        items: initialItems.map((item) => {
+            const node = { key: getKey(item), parentKey: parentKey ?? null, value: item, children: null };
+            node.children = buildTree(getKey, getChildren, getChildren(item), map, node.key).items;
+            map.set(node.key, node);
+            return node;
+        }),
+        nodeMap: map,
+    };
+}
+function addNode(node, map) {
+    map.set(node.key, node);
+    if (node.children)
+        for (const child of node.children)
+            addNode(child, map);
+}
+function deleteNode(node, map) {
+    map.delete(node.key);
+    if (node.children)
+        for (const child of node.children)
+            deleteNode(child, map);
+}
+function updateTree(items, key, update, originalMap) {
+    let node = key == null ? null : originalMap.get(key);
+    if (node == null)
+        return { items, nodeMap: originalMap };
+    const map = new Map(originalMap);
+    // Create a new node. If null, then delete the node, otherwise replace.
+    let newNode = update(node);
+    if (newNode == null)
+        deleteNode(node, map);
+    else
+        addNode(newNode, map);
+    // Walk up the tree and update each parent to refer to the new children.
+    while (node && node.parentKey) {
+        const nextParent = map.get(node.parentKey);
+        const copy = { key: nextParent.key, parentKey: nextParent.parentKey, value: nextParent.value, children: null };
+        let children = nextParent.children;
+        if (newNode == null && children)
+            children = children.filter((c) => c !== node);
+        const current = node;
+        const replacement = newNode;
+        copy.children = children?.map((child) => (child === current ? replacement : child)) ?? null;
+        map.set(copy.key, copy);
+        newNode = copy;
+        node = nextParent;
+    }
+    if (newNode == null)
+        items = items.filter((c) => c !== node);
+    const top = node;
+    const replacement = newNode;
+    return { items: items.map((item) => (item === top ? replacement : item)), nodeMap: map };
+}
+function moveItems(state, keys, toParent, toIndex, update, add) {
+    const { items, nodeMap } = state;
+    let parent = toParent;
+    const removeKeys = new Set(keys);
+    while (parent != null) {
+        if (removeKeys.has(parent.key))
+            throw new Error("Cannot move an item to be a child of itself.");
+        parent = parent.parentKey != null ? (nodeMap.get(parent.parentKey) ?? null) : null;
+    }
+    const originalToIndex = toIndex;
+    const keyArray = Array.isArray(keys) ? keys : [...keys];
+    // Depth first search to put keys in order.
+    const inOrderKeys = new Map();
+    const removedItems = [];
+    let newItems = items;
+    let newMap = nodeMap;
+    let i = 0;
+    function traversal(node, { inorder, postorder }) {
+        inorder?.(node);
+        if (node != null) {
+            for (const child of node.children ?? []) {
+                traversal(child, { inorder, postorder });
+                postorder?.(child);
+            }
+        }
+    }
+    function inorder(child) {
+        // In-order so we add items as we encounter them in the tree, then insert them in expected order later.
+        if (keyArray.includes(child.key))
+            inOrderKeys.set(child.key, i++);
+    }
+    function postorder(child) {
+        // Remove items and update the tree from the leaves upwards toward the root, so we don't copy
+        // child node references from parents inadvertently.
+        if (keyArray.includes(child.key)) {
+            removedItems.push({ ...newMap.get(child.key), parentKey: toParent?.key ?? null });
+            const { items: nextItems, nodeMap: nextMap } = update(newItems, child.key, () => null, newMap);
+            newItems = nextItems;
+            newMap = nextMap;
+        }
+        // Decrement the index if the child being removed is in the target parent and before the target
+        // index. The root is null and has no key, but a parentKey can still point to it.
+        if ((child.parentKey === toParent || child.parentKey === toParent?.key) &&
+            keyArray.includes(child.key) &&
+            (toParent?.children ? toParent.children.indexOf(child) : items.indexOf(child)) < originalToIndex) {
+            toIndex--;
+        }
+    }
+    traversal({ children: items }, { inorder, postorder });
+    const inOrderItems = removedItems.sort((a, b) => (inOrderKeys.get(a.key) > inOrderKeys.get(b.key) ? 1 : -1));
+    // If parentKey is null, insert into the root.
+    if (!toParent || toParent.key == null) {
+        inOrderItems.forEach((movedNode) => add(movedNode, newMap));
+        return { items: [...newItems.slice(0, toIndex), ...inOrderItems, ...newItems.slice(toIndex)], nodeMap: newMap };
+    }
+    // Otherwise, update the parent node and its ancestors.
+    return update(newItems, toParent.key, (parentNode) => ({
+        key: parentNode.key,
+        parentKey: parentNode.parentKey,
+        value: parentNode.value,
+        children: [...parentNode.children.slice(0, toIndex), ...inOrderItems, ...parentNode.children.slice(toIndex)],
+    }), newMap);
+}
+/** Default item key: `item.id ?? item.key` (react-stately). */
+const treeKey = (item) => item.id ?? item.key;
+/** Default children: `item.children` (react-stately). */
+const treeChildren = (item) => item.children;
+/**
+ * Manages state for an immutable tree data structure, and provides convenience methods to update
+ * the data over time (react-stately `useTreeData`).
+ */
+export function createTreeData(options = {}) {
+    return _regionState(() => {
+        const { initialItems = [], initialSelectedKeys } = options;
+        // Resumable: a module-level default is not a serializable capture; the fallback is an object-literal arrow (a resume symbol).
+        const userKey = options.getKey, userChildren = options.getChildren;
+        const fns = {
+            key: (item) => (userKey ? userKey(item) : treeKey(item)),
+            children: (item) => (userChildren ? userChildren(item) : treeChildren(item)),
+        };
+        const getKey = fns.key;
+        const getChildren = fns.children;
+        // We only want to compute this once.
+        const tree = signal(buildTree(getKey, getChildren, initialItems, new Map()));
+        const selectedKeys = signal(new Set(initialSelectedKeys || []));
+        const setItems = (fn) => tree.set(fn(untrack(tree)));
+        const current = () => untrack(tree);
+        const insert = (parentKey, index, ...values) => setItems(({ items, nodeMap: originalMap }) => {
+            const { items: newNodes, nodeMap: newMap } = buildTree(getKey, getChildren, values, new Map(originalMap), parentKey);
+            // If parentKey is null, insert into the root.
+            if (parentKey == null)
+                return { items: [...items.slice(0, index), ...newNodes, ...items.slice(index)], nodeMap: newMap };
+            // Otherwise, update the parent node and its ancestors.
+            return updateTree(items, parentKey, (parentNode) => ({
+                key: parentNode.key,
+                parentKey: parentNode.parentKey,
+                value: parentNode.value,
+                children: [...parentNode.children.slice(0, index), ...newNodes, ...parentNode.children.slice(index)],
+            }), newMap);
+        });
+        const remove = (...keys) => {
+            if (keys.length === 0)
+                return;
+            const { items, nodeMap } = current();
+            let newItems = items;
+            let prevMap = nodeMap;
+            let newTree;
+            for (const key of keys) {
+                newTree = updateTree(newItems, key, () => null, prevMap);
+                prevMap = newTree.nodeMap;
+                newItems = newTree.items;
+            }
+            const previous = untrack(selectedKeys);
+            batch(() => {
+                tree.set(newTree);
+                const selection = new Set(previous);
+                for (const key of previous)
+                    if (!newTree.nodeMap.has(key))
+                        selection.delete(key);
+                selectedKeys.set(selection);
+            });
+        };
+        const siblingIndex = (key) => {
+            const { items, nodeMap } = current();
+            const node = nodeMap.get(key);
+            if (!node)
+                return null;
+            const parentNode = nodeMap.get(node.parentKey);
+            const nodes = parentNode ? parentNode.children : items;
+            return { parentKey: parentNode?.key ?? null, index: nodes.indexOf(node) };
+        };
+        const moveRelative = (key, keys, after) => setItems((prevState) => {
+            const { items, nodeMap } = prevState;
+            const node = nodeMap.get(key);
+            if (!node)
+                return prevState;
+            const toParentKey = node.parentKey ?? null;
+            let parent = null;
+            if (toParentKey != null)
+                parent = nodeMap.get(toParentKey) ?? null;
+            let toIndex = parent?.children ? parent.children.indexOf(node) : items.indexOf(node);
+            if (after)
+                toIndex++;
+            return moveItems(prevState, keys, parent, toIndex, updateTree, addNode);
+        });
+        return {
+            items: () => tree().items,
+            selectedKeys,
+            setSelectedKeys: (keys) => selectedKeys.set(keys),
+            getItem: (key) => tree().nodeMap.get(key),
+            insert,
+            insertBefore: (key, ...values) => {
+                const at = siblingIndex(key);
+                if (at)
+                    insert(at.parentKey, at.index, ...values);
+            },
+            insertAfter: (key, ...values) => {
+                const at = siblingIndex(key);
+                if (at)
+                    insert(at.parentKey, at.index + 1, ...values);
+            },
+            prepend: (parentKey, ...values) => insert(parentKey, 0, ...values),
+            append: (parentKey, ...values) => {
+                const { items, nodeMap } = current();
+                if (parentKey == null)
+                    insert(null, items.length, ...values);
+                else {
+                    const parentNode = nodeMap.get(parentKey);
+                    if (!parentNode)
+                        return;
+                    insert(parentKey, parentNode.children.length, ...values);
+                }
+            },
+            remove,
+            removeSelectedItems: () => remove(...untrack(selectedKeys)),
+            move: (key, toParentKey, index) => setItems(({ items, nodeMap: originalMap }) => {
+                let walk = toParentKey;
+                while (walk != null) {
+                    if (walk === key)
+                        throw new Error("Cannot move an item to be a child of itself.");
+                    walk = originalMap.get(walk)?.parentKey ?? null;
+                }
+                const node = originalMap.get(key);
+                if (!node)
+                    return { items, nodeMap: originalMap };
+                const { items: newItems, nodeMap: newMap } = updateTree(items, key, () => null, originalMap);
+                const movedNode = { ...node, parentKey: toParentKey };
+                // If parentKey is null, insert into the root.
+                if (toParentKey == null) {
+                    addNode(movedNode, newMap);
+                    return { items: [...newItems.slice(0, index), movedNode, ...newItems.slice(index)], nodeMap: newMap };
+                }
+                // Otherwise, update the parent node and its ancestors.
+                return updateTree(newItems, toParentKey, (parentNode) => ({
+                    key: parentNode.key,
+                    parentKey: parentNode.parentKey,
+                    value: parentNode.value,
+                    children: [...parentNode.children.slice(0, index), movedNode, ...parentNode.children.slice(index)],
+                }), newMap);
+            }),
+            moveBefore: (key, keys) => moveRelative(key, keys, false),
+            moveAfter: (key, keys) => moveRelative(key, keys, true),
+            update: (oldKey, newValue) => setItems(({ items, nodeMap: originalMap }) => updateTree(items, oldKey, (oldNode) => {
+                const node = { key: oldNode.key, parentKey: oldNode.parentKey, value: newValue, children: null };
+                const built = buildTree(getKey, getChildren, getChildren(newValue), originalMap, node.key);
+                node.children = built.items;
+                return node;
+            }, originalMap)),
+        };
+    });
+}

package/data-grid/behaviour.d.ts

@@ -0,0 +1,95 @@
+import { type Signal } from "@rivetjs/reactivity";
+import { type ControlledState } from "../interactions/controllable.js";
+import { type DataGridColumnBase, type DataGridRow, type DropPosition, type Key, type Selection, type SelectionMode, type SortDescriptor, type VirtualWindow } from "./state.js";
+export type SelectionBehavior = "toggle" | "replace";
+/** Column ids of the utility columns the grid prepends. */
+export declare const SELECT_COLUMN = "__rv_select";
+export declare const DRAG_COLUMN = "__rv_drag";
+export interface DragState {
+    keys: Key[];
+    target: Key | null;
+    position: DropPosition;
+    keyboard: boolean;
+    /** Drop indicator offset in px from the top of the scroll content (`null`: hidden). */
+    indicator: number | null;
+}
+/** Arguments of `onReorder` (keys moved, drop target, the reordered top-level data). */
+export interface DataGridReorderEvent<T> {
+    keys: Set<Key>;
+    target: {
+        key: Key;
+        dropPosition: DropPosition;
+    };
+    /** `data` with the moved items placed at the target (top level; nested rows reorder among their siblings). */
+    items: T[];
+}
+/** What the handlers read and write (built by the component; plain data). */
+export interface DataGridContext<T> {
+    rows: () => DataGridRow<T>[];
+    /** Rendered columns (utility + data) in order. */
+    columns: () => DataGridColumnBase<T>[];
+    data: () => readonly T[];
+    getRowId: (item: T, index: number) => Key;
+    getChildren: (item: T) => readonly T[] | null | undefined;
+    selection: ControlledState<Selection>;
+    mode: () => SelectionMode;
+    behavior: () => SelectionBehavior;
+    disabled: () => ReadonlySet<Key>;
+    disallowEmpty: () => boolean;
+    sort: ControlledState<SortDescriptor | null>;
+    expanded: ControlledState<Set<Key>>;
+    widths: Signal<Map<string, number> | null>;
+    resizing: Signal<string | null>;
+    /** Last focused row key / column id (column `null`: the row itself). */
+    focus: Signal<{
+        key: Key | null;
+        col: string | null;
+    }>;
+    anchor: Signal<Key | null>;
+    win: Signal<VirtualWindow>;
+    drag: Signal<DragState | null>;
+    virtual: () => boolean;
+    rowHeight: () => number;
+    headerHeight: () => number;
+    overscan: () => number;
+    hasAction: () => boolean;
+    onRowAction: (key: Key) => void;
+    canReorder: () => boolean;
+    onReorder: (event: DataGridReorderEvent<T>) => void;
+    onColumnResize: (widths: Map<string, number>) => void;
+    onColumnResizeEnd: (widths: Map<string, number>) => void;
+    rtl: () => boolean;
+    /** Localized strings. */
+    strings: {
+        dragStart: string;
+        dragDrop: string;
+        dragCancel: string;
+    };
+}
+export declare const rowElement: (table: Element, key: Key) => HTMLElement | null;
+/** The row key of a `<tr data-key>` (numeric keys round-trip through `data-key-type`). */
+export declare function keyOf(row: Element): Key;
+/** Recompute the virtual window from the scroller (scroll handler, keyboard reveal). */
+export declare function updateWindow<T>(ctx: DataGridContext<T>, scroller: HTMLElement): void;
+/** Toggle `key` (Space, checkbox, toggle-mode press). */
+export declare function toggleRow<T>(ctx: DataGridContext<T>, key: Key): void;
+/** Select-all checkbox / Ctrl+A: "all" ↔ empty (react-stately `toggleSelectAll`). */
+export declare function toggleAll<T>(ctx: DataGridContext<T>): void;
+export declare function sortBy<T>(ctx: DataGridContext<T>, column: string): void;
+export declare function toggleExpanded<T>(ctx: DataGridContext<T>, key: Key): void;
+/** Delegated `click` on the `<table>`. */
+export declare function gridClick<T>(event: MouseEvent, ctx: DataGridContext<T>): void;
+/** Delegated `dblclick`: "replace" selection behaviour runs the row action on double click (RA). */
+export declare function gridDoubleClick<T>(event: MouseEvent, ctx: DataGridContext<T>): void;
+/** Delegated `focusin`: track the focused row / cell; the table leaves the tab order while focus is inside. */
+export declare function gridFocusIn<T>(event: FocusEvent, ctx: DataGridContext<T>): void;
+/** Delegated `focusout`: focus leaving the grid puts the table back in the tab order. */
+export declare function gridFocusOut(event: FocusEvent): void;
+/** Delegated `keydown` on the `<table>`. */
+export declare function gridKeyDown<T>(event: KeyboardEvent, ctx: DataGridContext<T>): void;
+/** Delegated `pointerdown`: column resizer drag, row drag handle. */
+export declare function gridPointerDown<T>(event: PointerEvent, ctx: DataGridContext<T>): void;
+/** Enter on a drag handle starts a keyboard drag (RA useDrag keyboard: Enter grab, arrows move, Enter drop, Escape cancel). */
+export declare function startKeyboardDrag<T>(ctx: DataGridContext<T>, table: HTMLTableElement, key: Key): void;
+/** `scroll` on the scroll container: virtual window + pinned-column separators (`data-scrolled-start` / `-end`). */
+export declare function gridScroll<T>(event: Event, ctx: DataGridContext<T>): void;