@1771technologies/lytenyte-pro 1.0.11 → 1.0.12-dev.1

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

@@ -1,511 +0,0 @@
-import {} from "../+types.js";
-import { useRef } from "react";
-import { traverse } from "./tree/traverse.js";
-import { computed, dateComparator, effect, makeAtom, numberComparator, peek, signal, stringComparator, } from "@1771technologies/lytenyte-shared";
-import { equal } from "@1771technologies/lytenyte-js-utils";
-import { makeClientTree } from "./tree/client-tree.js";
-import { computeFilteredRows } from "./filter/compute-filtered-rows.js";
-import { builtIns } from "./built-ins/built-ins.js";
-export function makeClientTreeDataSource(p) {
-    const data = signal(p.data);
-    const topData = signal(p.topData ?? []);
-    const bottomData = signal(p.bottomData ?? []);
-    const dataToSrc$ = computed(() => {
-        return new Map(data().map((c, i) => [c, i]));
-    });
-    const cache = new Map();
-    const centerNodes = computed(() => {
-        const nodes = [];
-        const d = data();
-        for (let i = 0; i < d.length; i++) {
-            if (!cache.has(i)) {
-                cache.set(i, {
-                    id: "",
-                    kind: "leaf",
-                    data: d[i],
-                });
-            }
-            const node = cache.get(i);
-            node.data = d[i];
-            nodes.push(node);
-        }
-        return nodes;
-    });
-    const topNodes = computed(() => {
-        return topData().map((c, i) => ({ data: c, id: `top-${i}`, kind: "leaf" }));
-    });
-    const botNodes = computed(() => {
-        return bottomData().map((c, i) => ({ data: c, id: `bottom-${i}`, kind: "leaf" }));
-    });
-    const pinnedIdMap = computed(() => {
-        const combined = new Map([...topNodes(), ...botNodes()].map((c) => [c.id, c]));
-        return combined;
-    });
-    const models = signal({
-        sort: [],
-        filter: {},
-        filterIn: {},
-        quickSearch: null,
-        agg: {},
-        groupExpansions: {},
-    });
-    const sortModel = computed(() => models().sort);
-    const filterModel = computed(() => models().filter);
-    const filterInModel = computed(() => models().filterIn);
-    const groupExpansions = computed(() => models().groupExpansions);
-    const aggModel = computed(() => models().agg);
-    const quickSearch = computed(() => models().quickSearch);
-    const grid$ = signal(null);
-    const snapshot = signal(0);
-    const tree = computed(() => {
-        snapshot();
-        const grid = grid$();
-        const rows = centerNodes();
-        const filtered = computeFilteredRows(rows, grid, filterModel(), filterInModel(), quickSearch(), grid?.state.quickSearchSensitivity.get() ?? "case-sensitive", false);
-        const rowAggModel = Object.entries(aggModel()).map(([name, agg]) => {
-            if (typeof agg.fn === "function") {
-                const fn = agg.fn;
-                return {
-                    name,
-                    fn: (rows) => fn(rows.map((c) => c.data), grid),
-                };
-            }
-            const key = agg.fn;
-            const fn = (data) => {
-                const fieldData = data.map((r) => grid?.api.columnField(name, { kind: "leaf", data: r.data }));
-                return builtIns[key](fieldData);
-            };
-            return { name, fn };
-        });
-        return makeClientTree({
-            rowData: filtered,
-            rowAggModel: grid ? rowAggModel : [],
-            rowBranchModel: p.getPathFromData,
-            rowIdGroup: p.rowIdBranch,
-            rowIdLeaf: p.rowIdLeaf,
-        });
-    });
-    const sortComparator = computed(() => {
-        const model = sortModel();
-        const grid = grid$();
-        if (!model.length || !grid)
-            return { fn: () => 0 };
-        const comparator = (l, r) => {
-            let res = 0;
-            for (const sortSpec of model) {
-                const sort = sortSpec.sort;
-                const columnId = sortSpec.columnId;
-                const ld = l.kind === 2
-                    ? { kind: "branch", data: l.data, key: l.key }
-                    : { kind: "leaf", data: l.data.data };
-                const rd = r.kind === 2
-                    ? { kind: "branch", data: r.data, key: r.key }
-                    : { kind: "leaf", data: r.data.data };
-                if (sort.kind === "custom") {
-                    res = sort.comparator(ld, rd, sort.options ?? {});
-                }
-                else if (sort.kind === "number") {
-                    const left = grid.api.columnField(columnId, ld);
-                    const right = grid.api.columnField(columnId, rd);
-                    res = numberComparator(left, right, sort.options ?? {});
-                }
-                else if (sort.kind === "date") {
-                    const left = grid.api.columnField(columnId, ld);
-                    const right = grid.api.columnField(columnId, rd);
-                    res = dateComparator(left, right, sort.options ?? {});
-                }
-                else if (sort.kind === "string") {
-                    const left = grid.api.columnField(columnId, ld);
-                    const right = grid.api.columnField(columnId, rd);
-                    res = stringComparator(left, right, sort.options ?? {});
-                }
-                else {
-                    res = 0;
-                }
-                res = sortSpec.isDescending ? -res : res;
-                if (res !== 0)
-                    break;
-            }
-            return res;
-        };
-        return { fn: comparator };
-    });
-    const idToNode = computed(() => {
-        const map = new Map();
-        traverse(tree().root, (node) => {
-            map.set(node.id, node);
-        });
-        return map;
-    });
-    const initialized = signal(false);
-    const flat = computed(() => {
-        if (!initialized())
-            return { flat: [], idMap: new Map(), idToIndexMap: new Map() };
-        const idMap = new Map();
-        const idToIndexMap = new Map();
-        const flattened = [];
-        const comparator = sortComparator();
-        const expansions = groupExpansions();
-        const defaultExpansion = grid$()?.state.rowGroupDefaultExpansion.get() ?? false;
-        let index = topNodes().length;
-        traverse(tree().root, (node) => {
-            if (node.kind === 1) {
-                node.data.id = node.id;
-                flattened.push(node.data);
-            }
-            else {
-                flattened.push({
-                    kind: "branch",
-                    data: node.data,
-                    id: node.id,
-                    key: node.key,
-                    depth: node.depth,
-                });
-            }
-            idMap.set(node.id, flattened.at(-1));
-            idToIndexMap.set(node.id, index);
-            index++;
-            if (node.kind === 2) {
-                const expanded = expansions[node.id] ??
-                    (typeof defaultExpansion === "number"
-                        ? node.depth <= defaultExpansion
-                        : defaultExpansion);
-                return expanded;
-            }
-        }, comparator.fn);
-        return { flat: flattened, idMap, idToIndexMap };
-    });
-    const flatLength = computed(() => flat().flat.length);
-    const cleanup = [];
-    const init = (grid) => {
-        while (cleanup.length)
-            cleanup.pop()?.();
-        grid$.set(grid);
-        const store = grid.state.rowDataStore;
-        // Monitor row count changes
-        const centerCount = flatLength();
-        const top = topData().length;
-        const bottom = bottomData().length;
-        store.rowCenterCount.set(centerCount);
-        store.rowTopCount.set(top);
-        store.rowBottomCount.set(bottom);
-        cleanup.push(effect(() => {
-            store.rowCenterCount.set(flatLength());
-            store.rowTopCount.set(topData().length);
-            store.rowBottomCount.set(bottomData().length);
-            grid.state.rowDataStore.rowClearCache();
-        }));
-        const sort = grid.state.sortModel.get();
-        const filter = grid.state.filterModel.get();
-        const filterIn = grid.state.filterInModel.get();
-        const agg = grid.state.aggModel.get();
-        const quickSearch = grid.state.quickSearch.get();
-        const groupExpansions = grid.state.rowGroupExpansions.get();
-        models.set({
-            agg,
-            filter,
-            filterIn,
-            groupExpansions,
-            quickSearch,
-            sort,
-        });
-        initialized.set(true);
-        cleanup.push(effect(() => {
-            models.set({
-                // @ts-expect-error The $ is defined, but only internally
-                sort: grid.state.sortModel.$(),
-                // @ts-expect-error The $ is defined, but only internally
-                agg: grid.state.aggModel.$(),
-                // @ts-expect-error The $ is defined, but only internally
-                filter: grid.state.filterModel.$(),
-                // @ts-expect-error The $ is defined, but only internally
-                group: grid.state.rowGroupModel.$(),
-                // @ts-expect-error The $ is defined, but only internally
-                groupExpansions: grid.state.rowGroupExpansions.$(),
-                // @ts-expect-error The $ is defined, but only internally
-                columnPivotGroupExpansions: grid.state.columnPivotColumnGroupExpansions.$(),
-                // @ts-expect-error The $ is defined, but only internally
-                filterIn: grid.state.filterInModel.$(),
-                // @ts-expect-error The $ is defined, but only internally
-                quickSearch: grid.state.quickSearch.$(),
-            });
-            grid.state.rowDataStore.rowClearCache();
-        }));
-    };
-    const rowById = (id) => {
-        const pinned = peek(pinnedIdMap);
-        if (pinned.has(id))
-            return pinned.get(id);
-        const t = peek(flat);
-        return t.idMap.get(id) ?? null;
-    };
-    const rowByIndex = (index) => {
-        const top = peek(topNodes);
-        const bot = peek(botNodes);
-        const center = peek(flat).flat;
-        const topOffset = top.length;
-        const centerOffset = topOffset + center.length;
-        const botOffset = centerOffset + bot.length;
-        if (index < topOffset)
-            return top[index];
-        if (index < centerOffset)
-            return center[index - topOffset];
-        if (index < botOffset)
-            return bot[index - centerOffset];
-        return null;
-    };
-    const rowUpdate = (updates) => {
-        const grid = peek(grid$);
-        const d = peek(data);
-        const idMap = peek(idToNode);
-        const dataToSrc = peek(dataToSrc$);
-        for (const [key, next] of updates.entries()) {
-            const row = typeof key === "string" ? rowById(key) : rowByIndex(key);
-            const treeNode = typeof key === "string" ? idMap.get(key) : null;
-            if ((!row && !treeNode) || !grid) {
-                console.error(`Failed to find the row with identifier ${key} which is being updated.`);
-                continue;
-            }
-            if (row?.kind === "branch") {
-                row.data = next;
-            }
-            else {
-                const data = row?.kind === "leaf" ? row.data : treeNode?.data.data;
-                const source = dataToSrc.get(data);
-                if (source == null) {
-                    console.error(`Failed to find the row with identifier ${key} which is being updated.`);
-                    continue;
-                }
-                d[source] = next;
-                cache.delete(source);
-            }
-        }
-        data.set([...d]);
-        snapshot.set((prev) => prev + 1);
-        grid.state.rowDataStore.rowClearCache();
-    };
-    const rowToIndex = (rowId) => {
-        const f = peek(flat);
-        const top = peek(topNodes);
-        const bot = peek(botNodes);
-        const topCount = top.length;
-        const center = f.flat.length;
-        const rowIndex = f.idToIndexMap.get(rowId);
-        if (rowIndex != null)
-            return rowIndex;
-        if (rowIndex == null) {
-            const foundTop = top.findIndex((row) => row.id === rowId);
-            if (foundTop !== -1)
-                return foundTop;
-            const foundBot = bot.findIndex((row) => row.id === rowId);
-            if (foundBot !== -1)
-                return foundBot + topCount + center;
-        }
-        return null;
-    };
-    const rowAllChildIds = (rowId) => {
-        const t = peek(tree);
-        const ids = [];
-        const node = t.idToNode.get(rowId);
-        if (node?.kind === 2) {
-            traverse(node, (n) => {
-                ids.push(n.id);
-            });
-        }
-        return ids;
-    };
-    return [
-        {
-            init,
-            rowById,
-            rowByIndex,
-            rowAllChildIds,
-            rowUpdate,
-            inFilterItems: (c) => {
-                const grid = peek(grid$);
-                if (!grid)
-                    return [];
-                const data = peek(centerNodes);
-                const values = new Set(data.map((row) => {
-                    const field = grid.api.columnField(c, row);
-                    return field;
-                }));
-                if (p.transformInFilterItem) {
-                    return p.transformInFilterItem({ column: c, values: [...values] });
-                }
-                return [...values].map((x) => ({ id: `${x}`, label: `${x}`, value: x }));
-            },
-            rowAdd: (newRows, place = "end") => {
-                data.set((prev) => {
-                    if (!newRows.length)
-                        return prev;
-                    let next;
-                    if (place === "beginning")
-                        next = [...newRows, ...prev];
-                    else if (place === "end")
-                        next = [...prev, ...newRows];
-                    else {
-                        next = [...prev];
-                        next.splice(place, 0, ...newRows);
-                    }
-                    return next;
-                });
-                const grid = peek(grid$);
-                grid?.state.rowDataStore.rowClearCache();
-            },
-            rowDelete: (rows) => {
-                const rowData = new Set(rows
-                    .map((c) => {
-                    if (typeof c === "number")
-                        return rowByIndex(c)?.data;
-                    else
-                        return rowById(c)?.data;
-                })
-                    .filter((c) => !!c));
-                data.set((prev) => {
-                    if (!rowData.size)
-                        return prev;
-                    return prev.filter((d) => !rowData.has(d));
-                });
-                const grid = peek(grid$);
-                grid?.state.rowDataStore.rowClearCache();
-            },
-            rowSetBotData: (data) => {
-                bottomData.set(data);
-                const grid = peek(grid$);
-                grid?.state.rowDataStore.rowClearCache();
-            },
-            rowSetTopData: (data) => {
-                topData.set(data);
-                const grid = peek(grid$);
-                grid?.state.rowDataStore.rowClearCache();
-            },
-            rowSetCenterData: (d) => {
-                data.set(d);
-                const grid = peek(grid$);
-                grid?.state.rowDataStore.rowClearCache();
-                cache.clear();
-            },
-            rowExpand: (expansions) => {
-                const grid = peek(grid$);
-                if (!grid)
-                    return;
-                grid.state.rowGroupExpansions.set((prev) => ({ ...prev, ...expansions }));
-            },
-            rowToIndex,
-            rowSelect: (params) => {
-                const grid = peek(grid$);
-                if (!grid)
-                    return;
-                if (params.mode === "none")
-                    return;
-                if (params.mode === "single") {
-                    if (params.deselect) {
-                        grid.state.rowSelectedIds.set(new Set());
-                    }
-                    else {
-                        grid.state.rowSelectedIds.set(new Set([params.startId]));
-                    }
-                    return;
-                }
-                const ids = new Set();
-                if (params.startId === params.endId) {
-                    ids.add(params.startId);
-                    if (params.selectChildren) {
-                        rowAllChildIds(params.startId).forEach((c) => ids.add(c));
-                    }
-                }
-                else {
-                    const first = rowToIndex(params.startId);
-                    const last = rowToIndex(params.endId);
-                    if (first == null || last == null)
-                        return;
-                    const start = Math.min(first, last);
-                    const end = Math.max(first, last);
-                    for (let i = start; i <= end; i++) {
-                        const row = rowByIndex(i);
-                        if (!row)
-                            continue;
-                        if (params.selectChildren) {
-                            rowAllChildIds(row.id).forEach((c) => ids.add(c));
-                        }
-                        if (row?.id)
-                            ids.add(row.id);
-                    }
-                }
-                if (params.deselect) {
-                    const current = grid.state.rowSelectedIds.get();
-                    const next = current.difference(ids);
-                    grid.state.rowSelectedIds.set(next);
-                }
-                else {
-                    const current = grid.state.rowSelectedIds.get();
-                    const next = current.union(ids);
-                    grid.state.rowSelectedIds.set(next);
-                }
-            },
-            rowSelectAll: (params) => {
-                const grid = peek(grid$);
-                if (!grid)
-                    return;
-                if (params.deselect) {
-                    grid.state.rowSelectedIds.set(new Set());
-                    return;
-                }
-                const t = peek(tree);
-                grid.state.rowSelectedIds.set(new Set(t.idsAll));
-            },
-            rowData: (section) => {
-                const d = [];
-                if (section === "top" || section === "flat") {
-                    d.push(...peek(topData));
-                }
-                if (section === "center" || section === "flat") {
-                    d.push(...peek(data));
-                }
-                if (section === "bottom" || section === "flat") {
-                    d.push(...peek(bottomData));
-                }
-                return d;
-            },
-            rowAreAllSelected: (rowId) => {
-                const g = grid$();
-                if (!g)
-                    return false;
-                const selected = g.state.rowSelectedIds.get();
-                if (rowId) {
-                    const row = rowById(rowId);
-                    if (!row)
-                        return false;
-                    const childIds = new Set(rowAllChildIds(rowId));
-                    return childIds.isSubsetOf(selected);
-                }
-                const f = tree();
-                return f.idsAll.isSubsetOf(selected);
-            },
-        },
-        {
-            top: makeAtom(topData),
-            center: makeAtom(data),
-            bottom: makeAtom(bottomData),
-        },
-    ];
-}
-export function useClientTreeDataSource(p) {
-    const ds = useRef(null);
-    const dataAtomRef = useRef(null);
-    if (!ds.current)
-        [ds.current, dataAtomRef.current] = makeClientTreeDataSource(p);
-    const da = dataAtomRef.current;
-    if (p.reflectData) {
-        // Need to queue the microtask since it we cannot update state during render.
-        if (p.data !== da.center.get())
-            queueMicrotask(() => ds.current.rowSetCenterData(p.data));
-        if (!equal(p.topData ?? [], da.top.get())) {
-            queueMicrotask(() => ds.current.rowSetTopData(p.topData ?? []));
-        }
-        if (!equal(p.bottomData ?? [], da.bottom.get()))
-            queueMicrotask(() => ds.current.rowSetBotData(p.bottomData ?? []));
-    }
-    return ds.current;
-}

package/dist/row-data-source-server/async-tree/+constants.async-tree.d.ts

@@ -1 +0,0 @@
-export declare const ROOT_LEAF_PREFIX = "__|#-Root-#|__";

package/dist/row-data-source-server/async-tree/+constants.async-tree.js

@@ -1 +0,0 @@
-export const ROOT_LEAF_PREFIX = "__|#-Root-#|__";

package/dist/row-data-source-server/async-tree/+types.async-tree.d.ts

@@ -1,59 +0,0 @@
-/**
- * The root of the async tree. This is the entry point of the tree.
- */
-export type TreeRoot<K, D> = {
-    readonly kind: "root";
-    readonly byPath: Map<string | null, LeafOrParent<K, D>>;
-    readonly byIndex: Map<number, LeafOrParent<K, D>>;
-    readonly size: number;
-    readonly asOf: number;
-};
-export type TreeParent<K, D> = {
-    readonly kind: "parent";
-    readonly relIndex: number;
-    readonly data: K;
-    readonly asOf: number;
-    readonly byPath: Map<string | null, LeafOrParent<K, D>>;
-    readonly byIndex: Map<number, LeafOrParent<K, D>>;
-    readonly size: number;
-    readonly path: string | null;
-    readonly parent: TreeParent<K, D> | TreeRoot<K, D>;
-};
-export type TreeLeaf<K, D> = {
-    readonly kind: "leaf";
-    readonly relIndex: number;
-    readonly data: D;
-    readonly asOf: number;
-    readonly parent: TreeParent<K, D> | TreeRoot<K, D>;
-    readonly path: string;
-};
-export type LeafOrParent<K, D> = TreeLeaf<K, D> | TreeParent<K, D>;
-export type TreeRootAndApi<K, D> = TreeRoot<K, D> & {
-    readonly set: (payload: SetDataAction<K, D>) => void;
-    readonly delete: (path: DeleteDataAction) => void;
-    readonly get: (payload: GetDataAction) => TreeRoot<K, D> | TreeParent<K, D> | null;
-};
-export interface SetDataAction<K = any, D = any> {
-    readonly path: (string | null)[];
-    readonly asOf?: number;
-    readonly size?: number;
-    readonly items?: ({
-        kind: "parent";
-        path: string | null;
-        data: K;
-        relIndex: number;
-        size: number;
-    } | {
-        kind: "leaf";
-        data: D;
-        relIndex: number;
-    })[];
-}
-export interface DeleteDataAction {
-    readonly path: (string | null)[];
-    readonly paths?: string[];
-    readonly relIndices?: number[];
-}
-export interface GetDataAction {
-    readonly path: (string | null)[];
-}

package/dist/row-data-source-server/async-tree/+types.async-tree.js

@@ -1 +0,0 @@
-export {};

package/dist/row-data-source-server/async-tree/apply-delete-action-to-tree.d.ts

@@ -1,2 +0,0 @@
-import type { DeleteDataAction, TreeRoot } from "./+types.async-tree";
-export declare function applyDeleteActionToTree<K, D>(p: DeleteDataAction, tree: TreeRoot<K, D>): void;

package/dist/row-data-source-server/async-tree/apply-delete-action-to-tree.js

@@ -1,27 +0,0 @@
-import { getParentNodeByPath } from "./get-parent-node-by-path.js";
-export function applyDeleteActionToTree(p, tree) {
-    // No op. We aren't deleting keys or indices
-    if (!p.relIndices?.length && !p.paths?.length)
-        return;
-    const parentNode = getParentNodeByPath(tree, p.path);
-    if (!parentNode)
-        return;
-    if (p.relIndices) {
-        for (const rel of p.relIndices) {
-            const node = parentNode.byIndex.get(rel);
-            if (!node)
-                continue;
-            parentNode.byPath.delete(node.path);
-            parentNode.byIndex.delete(rel);
-        }
-    }
-    if (p.paths) {
-        for (const path of p.paths) {
-            const node = parentNode.byPath.get(path);
-            if (!node)
-                continue;
-            parentNode.byPath.delete(node.path);
-            parentNode.byIndex.delete(node.relIndex);
-        }
-    }
-}

package/dist/row-data-source-server/async-tree/apply-set-action-to-tree.d.ts

@@ -1,2 +0,0 @@
-import type { SetDataAction, TreeRoot } from "./+types.async-tree.js";
-export declare function applySetActionToTree<K, D>(p: SetDataAction<K, D>, root: TreeRoot<K, D>): boolean;

package/dist/row-data-source-server/async-tree/apply-set-action-to-tree.js

@@ -1,36 +0,0 @@
-import { maybeApplyParentRemoveSelf } from "./maybe-apply-parent-remove-self.js";
-import { checkSetActionItemKeysAreUnique } from "./check-set-action-item-keys-are-unique.js";
-import { checkSetActionItemKeysAreValid } from "./check-set-action-item-keys-are-valid.js";
-import { checkSetActionItemKeysFit } from "./check-set-action-item-keys-fit.js";
-import { checkSetActionItemKinds } from "./check-set-action-item-kinds.js";
-import { getParentNodeByPath } from "./get-parent-node-by-path.js";
-import { isSetActionANoOpOnNode } from "./is-set-action-a-no-op-on-node.js";
-import { maybeApplyResize } from "./maybe-apply-resize.js";
-import { maybeApplySetActionItems } from "./maybe-apply-set-action-items.js";
-export function applySetActionToTree(p, root) {
-    // If we are not adding items and we are not resizing a node, then we just
-    // return our previous data and skip the update. This is effectively a no-op.
-    if (!p.items?.length && p.size == null)
-        return false;
-    // We need to find the parent that we are adding data to. Its possible the path is invalid.
-    // If we encounter an invalid path we return early without change. An invalid path is a
-    // path that does not exist or where there is a leaf node at some point in the path.
-    const pathNode = getParentNodeByPath(root, p.path);
-    if (!pathNode)
-        return false;
-    if (!checkSetActionItemKeysFit(p, pathNode))
-        return false;
-    if (!checkSetActionItemKinds(p))
-        return false;
-    if (!checkSetActionItemKeysAreValid(p))
-        return false;
-    if (!checkSetActionItemKeysAreUnique(p))
-        return false;
-    if (isSetActionANoOpOnNode(p, pathNode))
-        return false;
-    maybeApplyResize(pathNode, p.size, p.asOf ?? Date.now());
-    if (maybeApplyParentRemoveSelf(pathNode))
-        return true;
-    maybeApplySetActionItems(p, pathNode);
-    return true;
-}

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-are-unique.d.ts

@@ -1,2 +0,0 @@
-import type { SetDataAction } from "./+types.async-tree.js";
-export declare function checkSetActionItemKeysAreUnique<K, D>(p: SetDataAction<K, D>): boolean;

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-are-unique.js

@@ -1,24 +0,0 @@
-import { ROOT_LEAF_PREFIX } from "./+constants.async-tree.js";
-const invalidItemKeyDupes = "Invalid set action items, the same 'key' appears more than once";
-const invalidItemPathsDupes = "Invalid set action items, the same 'path' appears more than once";
-export function checkSetActionItemKeysAreUnique(p) {
-    const seenKeys = new Set();
-    const seenPaths = new Set();
-    if (!p.items?.length)
-        return true;
-    for (let i = p.items.length - 1; i >= 0; i--) {
-        const item = p.items[i];
-        if (seenKeys.has(item.relIndex)) {
-            console.error(invalidItemKeyDupes, p);
-            return false;
-        }
-        const pathId = item.kind === "leaf" ? `${p.path.at(-1) ?? ROOT_LEAF_PREFIX}#${item.relIndex}` : item.path;
-        if (seenPaths.has(pathId)) {
-            console.error(invalidItemPathsDupes, p);
-            return false;
-        }
-        seenPaths.add(pathId);
-        seenKeys.add(item.relIndex);
-    }
-    return true;
-}

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-are-valid.d.ts

@@ -1,2 +0,0 @@
-import type { SetDataAction } from "./+types.async-tree.js";
-export declare function checkSetActionItemKeysAreValid<K, D>(p: SetDataAction<K, D>): boolean;