@1771technologies/lytenyte-pro 1.0.20 → 2.0.0-dev.1

package/dist/data-source-server/use-server-data-source.js

@@ -0,0 +1,192 @@
+import { useMemo } from "react";
+import { usePiece, useOnRowsSelected, useRowIsSelected, useRowSelection, useRowsSelected, useEvent, useGlobalRefresh, useRowSelectionState, } from "@1771technologies/lytenyte-core/internal";
+import {} from "@1771technologies/lytenyte-shared";
+import { useRowByIndex } from "./source/use-row-by-index.js";
+import { useRowIndexToRowId } from "./source/use-row-index-to-row-id.js";
+import { useRowIdToRowIndex } from "./source/use-row-id-to-row-index.js";
+import { useRowById } from "./source/use-row-by-id.js";
+import { useOnViewChange } from "./source/use-on-view-change.js";
+import { useSourceState } from "./source/use-source-state.js";
+import { useSource } from "./source/use-source.js";
+import { useRowParents } from "./source/use-row-parents.js";
+import { useRowsBetween } from "./source/use-rows-between.js";
+import { useRowChildren } from "./source/use-row-children.js";
+import { useRowLeafs } from "./source/use-row-leafs.js";
+import { useOnRowsUpdated } from "./source/use-on-rows-updated.js";
+import { useRowDelete } from "./source/use-row-delete.js";
+import { useRowAdd } from "./source/use-row-add.js";
+import { useRowSiblings } from "./source/use-row-siblings.js";
+export function useServerDataSource(props) {
+    const isolatedSelected = props.rowsIsolatedSelection ?? false;
+    const state = useSourceState(props);
+    const isLoading$ = usePiece(state.isLoading);
+    const loadError$ = usePiece(state.loadingError);
+    const requestsForView$ = usePiece(state.requestsForView, state.setRequestsForView);
+    const top$ = usePiece(state.topCount);
+    const bot$ = usePiece(state.botCount);
+    const maxDepth$ = usePiece(state.maxDepth);
+    const rowCount$ = usePiece(state.rowCount);
+    const globalSignal = useGlobalRefresh();
+    const source = useSource(props, state, globalSignal);
+    const rowById = useRowById(source);
+    const rowIdToRowIndex = useRowIdToRowIndex(source);
+    const rowIndexToRowId = useRowIndexToRowId(source);
+    const rowParents = useRowParents(source);
+    const rowsBetween = useRowsBetween(source);
+    const rowChildren = useRowChildren(source);
+    const onViewChange = useOnViewChange(source, state.requestsForView, state.setRequestsForView);
+    const idSpec = useEvent((id) => {
+        const node = source.tree.rowIdToNode.get(id);
+        if (!node || node.kind === "leaf")
+            return null;
+        return { size: node.size, children: node.byIndex };
+    });
+    const { rootIds, rootCount } = useMemo(() => {
+        const subset = props.rowSelectionIdUniverseSubtractions ?? new Set();
+        const rootIds = new Set([...source.tree.byIndex.values()].map((x) => x.row.id)).difference(subset);
+        const additions = new Set(props.rowSelectionIdUniverseAdditions?.filter((x) => x.root).map((x) => x.id) ?? []).difference(subset);
+        return { rootIds: rootIds.union(additions), rootCount: source.tree.size };
+    }, [
+        props.rowSelectionIdUniverseAdditions,
+        props.rowSelectionIdUniverseSubtractions,
+        source.tree.byIndex,
+        source.tree.size,
+    ]);
+    // Handling row selection
+    const selectionState = useRowSelection(props.rowSelection, props.onRowSelectionChange, isolatedSelected, props.rowSelectKey ?? props.queryKey, useMemo(() => {
+        const subset = props.rowSelectionIdUniverseSubtractions ?? new Set();
+        if (!props.rowSelectionIdUniverseAdditions)
+            return state.idUniverse.difference(subset);
+        return state.idUniverse
+            .union(new Set(props.rowSelectionIdUniverseAdditions.map((x) => x.id)))
+            .difference(subset);
+    }, [props.rowSelectionIdUniverseAdditions, props.rowSelectionIdUniverseSubtractions, state.idUniverse]), rootIds, rootCount, globalSignal);
+    const onRowsSelected = useOnRowsSelected(selectionState, idSpec, rowParents, isolatedSelected, globalSignal);
+    const rowIsSelected = useRowIsSelected(selectionState, rowParents, rowById);
+    const rowsSelected = useRowsSelected(selectionState, source.tree.rowIdToNode, rowParents);
+    const rowSelectionState = useRowSelectionState(selectionState);
+    const rowLeafs = useRowLeafs(source);
+    const { rowByIndex, rowInvalidate } = useRowByIndex(source, selectionState, globalSignal, rowParents);
+    const setExpansions = state.onExpansionsChange;
+    const onRowsUpdated = useOnRowsUpdated(source, props.onRowDataChange, props.rowUpdateOptimistically, globalSignal);
+    const rowSiblings = useRowSiblings(source);
+    const rowDelete = useRowDelete(source, props.onRowsDeleted, props.rowUpdateOptimistically);
+    const rowAdd = useRowAdd(source, props.onRowsAdded, props.rowUpdateOptimistically);
+    const selection$ = usePiece(selectionState.rowSelectionsRaw);
+    const rowGroupsPresent$ = usePiece(props.hasRowBranches ?? "infer");
+    const rowSource = useMemo(() => {
+        const rowSource = {
+            rowById,
+            rowByIndex,
+            rowInvalidate,
+            rowIdToRowIndex,
+            rowIndexToRowId,
+            rowChildren,
+            rowsSelected,
+            rowIsSelected,
+            rowSelectionState,
+            rowDelete,
+            rowAdd,
+            rowUpdate: onRowsUpdated,
+            rowSiblings,
+            rowLeafs,
+            rowParents,
+            rowsBetween,
+            useTopCount: () => top$.useValue(),
+            useRowCount: () => rowCount$.useValue(),
+            useBottomCount: () => bot$.useValue(),
+            useRows: () => {
+                const rowCount = rowCount$.useValue();
+                const mappedMemo = useMemo(() => {
+                    return {
+                        get: (i) => {
+                            const row = source.flat.rowIndexToRow.get(i);
+                            if (!row && i >= 0 && i < rowCount) {
+                                return {
+                                    kind: "leaf",
+                                    id: `__loading__placeholder__${i}`,
+                                    data: {},
+                                    depth: 0,
+                                };
+                            }
+                            return row;
+                        },
+                        size: rowCount,
+                    };
+                }, [rowCount]);
+                return mappedMemo;
+            },
+            useMaxRowGroupDepth: () => {
+                const maxDepth = maxDepth$.useValue();
+                const presence = rowGroupsPresent$.useValue();
+                if (presence === "infer")
+                    return maxDepth;
+                return presence ? 1 : 0;
+            },
+            useSelectionState: selection$.useValue,
+            rowGroupExpansionChange: (deltaChanges) => {
+                setExpansions(deltaChanges);
+            },
+            onRowsSelected,
+            onViewChange,
+            onRowsUpdated,
+            // Specific to the server data source
+            isLoading: isLoading$,
+            loadingError: loadError$,
+            requestsForView: requestsForView$,
+            pushRequests: (requests) => source.handleRequests(requests),
+            pushResponses: source.handleResponses,
+            retry: () => {
+                source.retry();
+                rowSource.rowInvalidate();
+            },
+            refresh: (onSuccess, onError) => {
+                const requests = requestsForView$.get();
+                rowSource.pushRequests(requests, onSuccess, onError);
+            },
+            reset: () => source.reset(),
+            requestForGroup: (row) => {
+                const index = typeof row === "number" ? row : source.flat.rowIdToRowIndex.get(row.id);
+                if (index == null)
+                    return null;
+                return source.requestForGroup(index);
+            },
+            requestForNextSlice: (req) => source.requestForNextSlice(req),
+            get seenRequests() {
+                return source.flat?.seenRequests ?? new Set();
+            },
+        };
+        return rowSource;
+    }, [
+        bot$,
+        isLoading$,
+        loadError$,
+        maxDepth$,
+        onRowsSelected,
+        onRowsUpdated,
+        onViewChange,
+        requestsForView$,
+        rowAdd,
+        rowById,
+        rowByIndex,
+        rowChildren,
+        rowCount$,
+        rowDelete,
+        rowGroupsPresent$,
+        rowIdToRowIndex,
+        rowIndexToRowId,
+        rowInvalidate,
+        rowIsSelected,
+        rowLeafs,
+        rowParents,
+        rowSelectionState,
+        rowSiblings,
+        rowsBetween,
+        rowsSelected,
+        selection$.useValue,
+        setExpansions,
+        source,
+        top$,
+    ]);
+    return rowSource;
+}

package/dist/data-source-server/utils/get-node-depth.d.ts

@@ -0,0 +1,2 @@
+import type { TreeLeaf, TreeParent } from "../async-tree/types.js";
+export declare function getNodeDepth(node: TreeParent | TreeLeaf): number;

package/dist/data-source-server/utils/get-node-path.d.ts

@@ -0,0 +1,2 @@
+import type { TreeParent, TreeRoot } from "../async-tree/types.js";
+export declare function getNodePath(c: TreeRoot | TreeParent): (string | null)[];

package/dist/data-source-tree/source/use-controlled-state.d.ts

@@ -0,0 +1,8 @@
+import type { UseTreeDataSourceParams } from "../use-tree-data-source";
+export declare function useControlledState<T>({ onRowGroupExpansionChange, rowGroupDefaultExpansion, rowGroupExpansions, }: UseTreeDataSourceParams<T>): {
+    expansions: {
+        [rowId: string]: boolean | undefined;
+    };
+    onExpansionsChange: (delta: Record<string, boolean | undefined>) => void;
+    expandedFn: (id: string, depth: number) => boolean;
+};

package/dist/data-source-tree/source/use-controlled-state.js

@@ -0,0 +1,21 @@
+import { useControlled, useEvent } from "@1771technologies/lytenyte-core/internal";
+import { useCallback } from "react";
+export function useControlledState({ onRowGroupExpansionChange, rowGroupDefaultExpansion = false, rowGroupExpansions, }) {
+    const [expansions, setExpansions] = useControlled({
+        controlled: rowGroupExpansions,
+        default: {},
+    });
+    const onExpansionsChange = useEvent((delta) => {
+        setExpansions({ ...expansions, ...delta });
+        onRowGroupExpansionChange?.({ ...expansions, ...delta });
+    });
+    const expandedFn = useCallback((id, depth) => {
+        const s = expansions[id];
+        if (s != null)
+            return s;
+        if (typeof rowGroupDefaultExpansion === "boolean")
+            return rowGroupDefaultExpansion;
+        return depth <= rowGroupDefaultExpansion;
+    }, [expansions, rowGroupDefaultExpansion]);
+    return { expansions, onExpansionsChange, expandedFn };
+}

package/dist/data-source-tree/source/use-flattened.d.ts

@@ -0,0 +1,17 @@
+import type { TreeRoot } from "../types";
+import type { RowAggregated, RowLeaf, RowNode, SortFn } from "@1771technologies/lytenyte-shared";
+export declare function useFlattened<T>(tree: TreeRoot, expandFn: (id: string, depth: number) => boolean, top: (RowLeaf<T> | RowAggregated)[] | undefined, bot: (RowLeaf<T> | RowAggregated)[] | undefined, idUniverseAdditions: {
+    readonly id: string;
+    readonly root: boolean;
+}[] | null | undefined, idUniverseSubtractions: Set<string> | null | undefined, sort: SortFn<T> | null | undefined): {
+    idUniverse: Set<string>;
+    rootIds: Set<string>;
+    rootCount: number;
+    rows: RowNode<T>[];
+    indexToRow: Map<number, RowNode<T>>;
+    idToIndex: Map<string, number>;
+    rowCount: number;
+    topCount: number;
+    botCount: number;
+    maxDepth: number;
+};

package/dist/data-source-tree/source/use-flattened.js

@@ -0,0 +1,65 @@
+import { useMemo } from "react";
+const empty = [];
+export function useFlattened(tree, expandFn, top = empty, bot = empty, idUniverseAdditions, idUniverseSubtractions, sort) {
+    const flat = useMemo(() => {
+        const stack = [...tree.children.values()];
+        if (sort)
+            stack.sort((l, r) => sort(l.row, r.row));
+        const indexToRow = new Map();
+        const idToIndex = new Map();
+        const rows = [...top];
+        top.map((x, i) => {
+            indexToRow.set(i, x);
+            idToIndex.set(x.id, i);
+        });
+        let maxDepth = 0;
+        while (stack.length) {
+            const node = stack.shift();
+            indexToRow.set(rows.length, node.row);
+            idToIndex.set(node.row.id, rows.length);
+            rows.push(node.row);
+            if (node.kind === "parent")
+                maxDepth = Math.max(maxDepth, node.row.depth + 1);
+            if (node.kind === "parent" && expandFn(node.row.id, node.row.depth) && node.row.expandable) {
+                node.row.expanded = true;
+                const children = [...node.children.values()];
+                if (sort)
+                    children.sort((l, r) => sort(l.row, r.row));
+                stack.unshift(...children);
+            }
+            else if (node.kind === "parent") {
+                node.row.expanded = false;
+            }
+        }
+        rows.push(...bot);
+        bot.map((x, i) => {
+            indexToRow.set(i, x);
+            idToIndex.set(x.id, i);
+        });
+        return {
+            rows,
+            indexToRow,
+            idToIndex,
+            rowCount: rows.length,
+            topCount: top.length,
+            botCount: bot.length,
+            maxDepth,
+        };
+    }, [bot, expandFn, sort, top, tree.children]);
+    return useMemo(() => {
+        const initialSet = new Set(tree.rowIdToNode.keys());
+        top.map((x) => initialSet.add(x.id));
+        bot.map((x) => initialSet.add(x.id));
+        const subSet = idUniverseSubtractions ?? new Set();
+        const rootAdds = idUniverseAdditions?.filter((x) => x.root)?.map((x) => x.id) ?? [];
+        const rootIds = new Set([...tree.children.values().map((x) => x.row.id)].concat(rootAdds)).difference(subSet);
+        return {
+            ...flat,
+            idUniverse: idUniverseAdditions
+                ? initialSet.union(new Set(idUniverseAdditions.map((x) => x.id) ?? [])).difference(subSet)
+                : initialSet.difference(subSet),
+            rootIds,
+            rootCount: rootIds.size,
+        };
+    }, [bot, flat, idUniverseAdditions, idUniverseSubtractions, top, tree.children, tree.rowIdToNode]);
+}

package/dist/data-source-tree/source/use-on-rows-updated.d.ts

@@ -0,0 +1,3 @@
+import type { UseTreeDataSourceParams } from "../use-tree-data-source";
+import type { TreeRoot } from "../types";
+export declare function useOnRowsUpdated<T>(tree: TreeRoot, p: UseTreeDataSourceParams<T>): (rows: Map<import("@1771technologies/lytenyte-shared").RowNode<any>, any>) => void;

package/dist/data-source-tree/source/use-on-rows-updated.js

@@ -0,0 +1,49 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useOnRowsUpdated(tree, p) {
+    const onRowsUpdate = useEvent((updates) => {
+        if (!p.onRowDataChange)
+            return;
+        const changes = [];
+        const top = new Map();
+        const bottom = new Map();
+        for (const [row, u] of updates) {
+            // Updating data
+            if (row.kind === "branch") {
+                const node = tree.rowIdToNode.get(row.id);
+                if (!node) {
+                    console.error(`Attempting to update a node that does not exist: ${row.id}`);
+                    return;
+                }
+                let current = node.parent;
+                const path = [];
+                while (current.kind !== "root") {
+                    path.push(current.key);
+                    current = current.parent;
+                }
+                path.reverse();
+                changes.push({
+                    key: node.key,
+                    next: u,
+                    parent: node?.parent.data,
+                    prev: node.data,
+                    path,
+                });
+                continue;
+            }
+            const topIndex = p.topData?.findIndex((r) => r.id === row.id);
+            if (topIndex != null && topIndex !== -1) {
+                top.set(topIndex, u);
+                continue;
+            }
+            const botIndex = p.botData?.findIndex((r) => r.id === row.id);
+            if (botIndex != null && botIndex !== -1) {
+                bottom.set(botIndex, u);
+                continue;
+            }
+            console.error(`Attempting to update a node that does not exist: ${row.id}`);
+            return;
+        }
+        p.onRowDataChange({ changes, top, bottom });
+    });
+    return onRowsUpdate;
+}

package/dist/data-source-tree/source/use-row-by-id.d.ts

@@ -0,0 +1,2 @@
+import type { TreeRoot } from "../types.js";
+export declare function useRowById(tree: TreeRoot): (id: string) => import("@1771technologies/lytenyte-shared").RowNode<any> | null;

package/dist/data-source-tree/source/use-row-by-id.js

@@ -0,0 +1,7 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowById(tree) {
+    const rowById = useEvent((id) => {
+        return tree.rowIdToNode.get(id)?.row ?? null;
+    });
+    return rowById;
+}

package/dist/data-source-tree/source/use-row-children.d.ts

@@ -0,0 +1,2 @@
+import type { TreeRoot } from "../types";
+export declare function useRowChildren(tree: TreeRoot): (id: string) => string[];

package/dist/data-source-tree/source/use-row-children.js

@@ -0,0 +1,11 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowChildren(tree) {
+    const rowChildren = useEvent((id) => {
+        const node = tree.rowIdToNode.get(id);
+        if (!node)
+            return [];
+        const ids = [...node.children.values()].map((x) => x.row.id);
+        return ids;
+    });
+    return rowChildren;
+}

package/dist/data-source-tree/source/use-row-leafs.d.ts

@@ -0,0 +1,2 @@
+import type { TreeRoot } from "../types";
+export declare function useRowLeafs(tree: TreeRoot): (id: string) => string[];

package/dist/data-source-tree/source/use-row-leafs.js

@@ -0,0 +1,20 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowLeafs(tree) {
+    const rowLeafs = useEvent((id) => {
+        const node = tree.rowIdToNode.get(id);
+        if (!node || !node.row.expandable)
+            return [];
+        const rows = [];
+        const stack = [...node.children.values()];
+        while (stack.length) {
+            const next = stack.pop();
+            if (!next.row.expandable)
+                rows.push(next.row.id);
+            else {
+                stack.push(...next.children.values());
+            }
+        }
+        return rows;
+    });
+    return rowLeafs;
+}

package/dist/data-source-tree/source/use-row-parents.d.ts

@@ -0,0 +1,2 @@
+import type { TreeRoot } from "../types.js";
+export declare function useRowParents(tree: TreeRoot): (id: string) => string[];

package/dist/data-source-tree/source/use-row-parents.js

@@ -0,0 +1,16 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowParents(tree) {
+    const rowParents = useEvent((id) => {
+        const node = tree.rowIdToNode.get(id);
+        if (!node)
+            return [];
+        const parents = [];
+        let current = node.parent;
+        while (current && current.kind !== "root") {
+            parents.push(current.row.id);
+            current = current.parent;
+        }
+        return parents.reverse();
+    });
+    return rowParents;
+}

package/dist/data-source-tree/source/use-row-siblings.d.ts

@@ -0,0 +1,2 @@
+import type { TreeRoot } from "../types";
+export declare function useRowSiblings(tree: TreeRoot): (id: string) => string[];

package/dist/data-source-tree/source/use-row-siblings.js

@@ -0,0 +1,12 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowSiblings(tree) {
+    const rowChildren = useEvent((id) => {
+        const node = tree.rowIdToNode.get(id);
+        const parent = node?.parent;
+        if (!parent)
+            return [];
+        const ids = [...parent.children.values()].map((x) => x.row.id);
+        return ids;
+    });
+    return rowChildren;
+}

package/dist/data-source-tree/source/use-tree.d.ts

@@ -0,0 +1,3 @@
+import type { TreeRoot } from "../types";
+import type { UseTreeDataSourceParams } from "../use-tree-data-source";
+export declare function useTree<T>({ data, filter, idFn, rowValueFn, rowChildrenFn, rowRootFn, }: UseTreeDataSourceParams<T>): TreeRoot;

package/dist/data-source-tree/source/use-tree.js

@@ -0,0 +1,59 @@
+import { useMemo } from "react";
+import { isObject } from "../utils/is-object.js";
+const defaultIdFn = (path) => path.join("-->");
+const rowValueFnDefault = (x) => {
+    if (!isObject(x))
+        return null;
+    const entries = Object.entries(x).filter((v) => !isObject(v[1]));
+    return Object.fromEntries(entries);
+};
+const rowChildrenFnDefault = (x) => {
+    if (!isObject(x))
+        return [];
+    return Object.entries(x).filter((x) => isObject(x[1]));
+};
+export function useTree({ data, filter, idFn = defaultIdFn, rowValueFn = rowValueFnDefault, rowChildrenFn = rowChildrenFnDefault, rowRootFn = Object.entries, }) {
+    const rowTree = useMemo(() => {
+        const root = {
+            kind: "root",
+            children: new Map(),
+            rowIdToNode: new Map(),
+            data,
+        };
+        const groupKeys = (parent, path, row, parentObj) => {
+            const value = rowValueFn(row, parentObj, path.at(-1));
+            const entries = rowChildrenFn(row, parentObj, path.at(-1));
+            if (filter && !filter(value))
+                return;
+            const expandable = entries.some((x) => isObject(x[1]));
+            const node = {
+                kind: "parent",
+                children: new Map(),
+                parent,
+                path,
+                data: row,
+                key: path.at(-1),
+                row: {
+                    kind: "branch",
+                    depth: path.length - 1,
+                    expandable,
+                    expanded: false,
+                    key: path.at(-1),
+                    last: !expandable,
+                    id: idFn(path, value),
+                    data: value,
+                    parentId: parent.kind === "root" ? null : parent.row.id,
+                },
+            };
+            parent.children.set(path.at(-1), node);
+            root.rowIdToNode.set(node.row.id, node);
+            entries.forEach((x) => groupKeys(node, [...path, x[0]], x[1], row));
+        };
+        const rootRows = rowRootFn(data);
+        for (const [path, row] of rootRows) {
+            groupKeys(root, [path], row, data);
+        }
+        return root;
+    }, [data, filter, idFn, rowChildrenFn, rowRootFn, rowValueFn]);
+    return rowTree;
+}

package/dist/data-source-tree/types.d.ts

@@ -0,0 +1,16 @@
+import type { RowGroup } from "@1771technologies/lytenyte-shared";
+export type TreeRoot = {
+    readonly kind: "root";
+    readonly children: Map<string, TreeParent>;
+    readonly rowIdToNode: Map<string, TreeParent>;
+    readonly data: object;
+};
+export type TreeParent = {
+    readonly kind: "parent";
+    readonly row: RowGroup;
+    readonly children: Map<string, TreeParent>;
+    readonly path: string[];
+    readonly parent: TreeParent | TreeRoot;
+    readonly data: object;
+    readonly key: string;
+};

package/dist/data-source-tree/use-tree-data-source.d.ts

@@ -0,0 +1,41 @@
+import type { DimensionSort, RowAggregated, RowLeaf, RowNode, RowSelectionState, RowSource, SortFn } from "@1771technologies/lytenyte-shared";
+export interface UseTreeDataSourceParams<T = unknown> {
+    readonly topData?: (RowLeaf<T> | RowAggregated)[];
+    readonly botData?: (RowLeaf<T> | RowAggregated)[];
+    readonly data: Record<string, unknown>;
+    readonly idFn?: (path: string[], data: any) => string;
+    readonly rowRootFn?: (x: object) => [key: string, child: object][];
+    readonly rowValueFn?: (x: any, parent: any, key: string) => any;
+    readonly rowChildrenFn?: (x: any, parent: any, key: string) => [key: string, child: object][];
+    readonly rowGroupExpansions?: {
+        [rowId: string]: boolean | undefined;
+    };
+    readonly rowGroupDefaultExpansion?: boolean | number;
+    readonly onRowGroupExpansionChange?: (state: Record<string, boolean | undefined>) => void;
+    readonly sort?: SortFn<any> | DimensionSort<any>[] | null;
+    readonly filter?: ((data: any) => boolean) | null;
+    readonly rowsIsolatedSelection?: boolean;
+    readonly rowSelectKey?: unknown[];
+    readonly rowSelection?: RowSelectionState;
+    readonly rowSelectionIdUniverseAdditions?: {
+        readonly id: string;
+        root: boolean;
+    }[];
+    readonly rowSelectionIdUniverseSubtractions?: Set<string>;
+    readonly onRowSelectionChange?: (state: RowSelectionState) => void;
+    readonly onRowDataChange?: (params: {
+        readonly changes: {
+            next: any;
+            prev: any;
+            parent: any;
+            key: string;
+            path: string[];
+        }[];
+        readonly top: Map<number, T>;
+        readonly bottom: Map<number, T>;
+    }) => void;
+}
+export interface RowSourceTree<T> extends RowSource<T> {
+    readonly rowUpdate: (rows: Map<RowNode<T>, T>) => void;
+}
+export declare function useTreeDataSource<T>(p: UseTreeDataSourceParams<T>): RowSource;