@1771technologies/lytenyte-pro 2.0.0-dev.0 → 2.0.0-dev.2

package/dist/data-source-client/hooks/use-pivot/use-pivot-data.d.ts

@@ -0,0 +1,32 @@
+import type { GridSpec } from "../../../types";
+import type { UseClientDataSourceParams } from "../../use-client-data-source";
+import type { SourceState } from "../use-controlled-ds-state";
+import { type RowLeaf } from "@1771technologies/lytenyte-shared";
+import { type LeafNodeTuple } from "@1771technologies/lytenyte-core/internal";
+import { type ControlledPivotState } from "./use-pivot-state.js";
+export declare function usePivotData<Spec extends GridSpec>(props: UseClientDataSourceParams<Spec>, [, leafs, , pinMap]: LeafNodeTuple<Spec["data"]>, c: SourceState, controlled: ControlledPivotState): {
+    tree: import("../use-group-tree/use-group-tree.js").RootNode<Spec["data"]> | null;
+    maxDepth: number;
+    flatten: import("@1771technologies/lytenyte-shared").RowNode<any>[];
+    rowByIdRef: import("react").RefObject<Map<string, import("@1771technologies/lytenyte-shared").RowNode<any>>>;
+    rowByIndexRef: import("react").RefObject<Map<number, import("@1771technologies/lytenyte-shared").RowNode<any>>>;
+    rowIdToRowIndexRef: import("react").RefObject<Map<string, number>>;
+    leafIdsRef: import("react").RefObject<Map<string, RowLeaf<Spec["data"]>>>;
+    leafsTop: RowLeaf<any>[] | {
+        id: string;
+        data: Record<string, unknown>;
+        kind: "aggregated";
+        depth: number;
+    }[];
+    leafs: RowLeaf<Spec["data"]>[];
+    leafsBot: RowLeaf<any>[] | {
+        id: string;
+        data: Record<string, unknown>;
+        kind: "aggregated";
+        depth: number;
+    }[];
+    sorted: number[];
+    pivotPiece: import("@1771technologies/lytenyte-core").Piece<import("../../../types").Column<Spec>[] | null>;
+    pivotGroupPiece: import("@1771technologies/lytenyte-core").Piece<Record<string, boolean>>;
+    groupFn: import("@1771technologies/lytenyte-shared").GroupFn<Spec["data"]> | null;
+};

package/dist/data-source-client/hooks/use-pivot/use-pivot-data.js

@@ -0,0 +1,83 @@
+import { useMemo, useRef } from "react";
+import { useFilteredData } from "./use-filtered-data.js";
+import { usePivotGroupFn } from "./use-pivot-group-fn.js";
+import { useGroupTree } from "../use-group-tree/use-group-tree.js";
+import {} from "@1771technologies/lytenyte-shared";
+import { useFlattenedGroups } from "../use-flattened-groups.js";
+import { useFlattenedPiece } from "../use-flattened-piece.js";
+import { usePivotColumns } from "./use-pivot-columns.js";
+import { usePivotAggFunction } from "./use-agg-model.js";
+import { useFilterFn, usePiece, useSortFn, } from "@1771technologies/lytenyte-core/internal";
+import {} from "./use-pivot-state.js";
+const empty = [];
+const groupIdFallback = (p) => p.map((x) => (x == null ? "_null_" : x)).join("->");
+export function usePivotData(props, [, leafs, , pinMap], c, controlled) {
+    const model = props.pivotModel;
+    const pivotMode = props.pivotMode ?? false;
+    const sortFn = useSortFn(model?.sort);
+    const filterFn = useFilterFn(props.filter);
+    const filter = props.pivotApplyExistingFilter ? filterFn : null;
+    const filtered = useFilteredData(pivotMode, filter, leafs);
+    const groupFn = usePivotGroupFn(pivotMode, model);
+    const leafIds = useMemo(() => {
+        const centerMap = new Map(pinMap);
+        for (let i = 0; i < filtered.length; i++) {
+            const row = leafs[filtered[i]];
+            centerMap.set(row.id, row);
+        }
+        return centerMap;
+    }, [filtered, leafs, pinMap]);
+    const leafIdsRef = useRef(leafIds);
+    leafIdsRef.current = leafIds;
+    const measures = model?.measures;
+    const rows = model?.rows;
+    const pivotColumns = usePivotColumns(pivotMode, controlled, model, leafs, filtered, props.pivotColumnProcessor);
+    const aggFn = usePivotAggFunction(pivotColumns, model, props.aggregateFns);
+    const tree = useGroupTree(leafs, filtered, groupFn, props.groupIdFn ?? groupIdFallback, "no-collapse", model?.rowLabelFilter, model?.filter, aggFn);
+    const [groupFlat, maxDepth] = useFlattenedGroups(tree, aggFn, leafs, filtered, sortFn, c.pivotExpandedFn, true, true);
+    const grandTotalRow = props.pivotGrandTotals;
+    const grandTotal = useMemo(() => {
+        if (!grandTotalRow || !aggFn)
+            return empty;
+        const rows = filtered.map((x) => leafs[x]);
+        const agg = aggFn(rows);
+        return [{ id: "ln-pivot-grand-total", data: agg, kind: "aggregated", depth: 0 }];
+    }, [aggFn, filtered, grandTotalRow, leafs]);
+    const top = grandTotalRow === "top" ? grandTotal : empty;
+    const bot = grandTotalRow === "bottom" ? grandTotal : empty;
+    const { flatten, rowByIdRef, rowByIndexRef, rowIdToRowIndexRef } = useFlattenedPiece({
+        leafsTop: top,
+        leafsCenter: leafs,
+        leafsBot: bot,
+        groupFlat,
+        centerIndices: filtered,
+    });
+    const pivotPiece = usePiece(pivotColumns);
+    const pivotGroupPiece = usePiece(controlled.pivotGroupState);
+    const trueMaxDepth = useMemo(() => {
+        if (!model?.rows?.length)
+            return 0;
+        return maxDepth;
+    }, [maxDepth, model?.rows?.length]);
+    const finalFlat = useMemo(() => {
+        if (!measures?.length && !rows?.length)
+            return [];
+        return flatten;
+    }, [flatten, measures?.length, rows?.length]);
+    return {
+        tree,
+        maxDepth: trueMaxDepth,
+        flatten: finalFlat,
+        rowByIdRef,
+        rowByIndexRef,
+        rowIdToRowIndexRef,
+        leafIdsRef,
+        leafsTop: top,
+        leafs,
+        leafsBot: bot,
+        sorted: filtered,
+        pivotPiece,
+        pivotGroupPiece,
+        groupFn,
+    };
+}

package/dist/data-source-client/hooks/use-pivot/use-pivot-group-fn.d.ts

@@ -0,0 +1,4 @@
+import type { GridSpec } from "../../../types/index.js";
+import type { GroupFn } from "@1771technologies/lytenyte-shared";
+import type { PivotModel } from "../../use-client-data-source.js";
+export declare function usePivotGroupFn<Spec extends GridSpec>(pivotMode: boolean, model: PivotModel<Spec> | undefined): GroupFn<Spec["data"]> | null;

package/dist/data-source-client/hooks/use-pivot/use-pivot-group-fn.js

@@ -0,0 +1,23 @@
+import { useMemo } from "react";
+import { computeField } from "@1771technologies/lytenyte-core/internal";
+export function usePivotGroupFn(pivotMode, model) {
+    const groupFn = useMemo(() => {
+        const pivotRows = model?.rows;
+        if (!pivotMode || !pivotRows?.length)
+            return () => [null];
+        const fn = (row) => {
+            const paths = [];
+            for (const c of pivotRows) {
+                const field = c.field ?? c.id;
+                const value = field ? computeField(field, row) : null;
+                if (value == null)
+                    paths.push(null);
+                else
+                    paths.push(String(value));
+            }
+            return paths;
+        };
+        return fn;
+    }, [model?.rows, pivotMode]);
+    return groupFn;
+}

package/dist/data-source-client/hooks/use-pivot/use-pivot-state.d.ts

@@ -0,0 +1,16 @@
+import type { PivotState } from "./use-pivot-columns";
+export type ControlledPivotState = ReturnType<typeof usePivotState>;
+export declare function usePivotState(state: PivotState | undefined, onPivotStateChange: undefined | ((p: PivotState) => void)): {
+    state: PivotState;
+    setState: (newValue: PivotState | ((prevValue: PivotState) => PivotState)) => void;
+    pivotColumnState: {
+        readonly ordering: string[];
+        readonly resizing: Record<string, number>;
+        readonly pinning: Record<string, import("@1771technologies/lytenyte-shared").ColumnPin>;
+    };
+    onPivotColumnStateChange: (change: PivotState["columnState"]) => void;
+    pivotGroupState: Record<string, boolean>;
+    onPivotGroupStateChange: (change: PivotState["columnGroupState"]) => void;
+    pivotRowGroupExpansions: Record<string, boolean | undefined>;
+    onPivotRowGroupChange: (change: PivotState["rowGroupExpansions"]) => void;
+};

package/dist/data-source-client/hooks/use-pivot/use-pivot-state.js

@@ -0,0 +1,40 @@
+import { useControlled, useEvent } from "@1771technologies/lytenyte-core/internal";
+import { useMemo } from "react";
+export function usePivotState(state, onPivotStateChange) {
+    const [pivotState, setPivotState] = useControlled({
+        controlled: state,
+        default: {
+            columnState: { ordering: [], pinning: {}, resizing: {} },
+            columnGroupState: {},
+            rowGroupExpansions: {},
+        },
+    });
+    const pivotColumnState = useMemo(() => pivotState.columnState, [pivotState.columnState]);
+    const onPivotColumnStateChange = useEvent((change) => {
+        const next = { ...pivotState, columnState: change };
+        setPivotState(next);
+        onPivotStateChange?.(next);
+    });
+    const pivotGroupState = useMemo(() => pivotState.columnGroupState, [pivotState.columnGroupState]);
+    const onPivotGroupStateChange = useEvent((change) => {
+        const next = { ...pivotState, pivotGroupState: change };
+        setPivotState(next);
+        onPivotStateChange?.(next);
+    });
+    const pivotRowGroupExpansions = useMemo(() => pivotState.rowGroupExpansions, [pivotState.rowGroupExpansions]);
+    const onPivotRowGroupChange = useEvent((change) => {
+        const next = { ...pivotState, rowGroupExpansions: change };
+        setPivotState(next);
+        onPivotStateChange?.(next);
+    });
+    return {
+        state: pivotState,
+        setState: setPivotState,
+        pivotColumnState,
+        onPivotColumnStateChange,
+        pivotGroupState,
+        onPivotGroupStateChange,
+        pivotRowGroupExpansions,
+        onPivotRowGroupChange,
+    };
+}

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

@@ -0,0 +1,91 @@
+import type { AggregationFn, Aggregator, Dimension, DimensionAgg, DimensionSort, FilterFn, GroupFn, GroupIdFn, LeafIdFn, RowGroup, RowLeaf, RowNode, RowSelectionState, RowSource, SortFn } from "@1771technologies/lytenyte-shared";
+import type { Column, Field } from "../types/column.js";
+import type { GridSpec } from "../types/grid.js";
+import type { PivotState } from "./hooks/use-pivot/use-pivot-columns.js";
+import type { Props } from "../types/props.js";
+export type PivotField<Spec extends GridSpec = GridSpec> = {
+    field?: Field<Spec["data"]>;
+};
+export type HavingFilterFn = (node: RowGroup) => boolean;
+export interface RowSourceClient<Spec extends GridSpec = GridSpec> extends RowSource<Spec["data"]> {
+    readonly usePivotProps: () => {
+        readonly columns?: Column<Spec>[];
+        readonly onColumnsChange: Props<Spec>["onColumnsChange"];
+        readonly columnGroupExpansions: Props<Spec>["columnGroupExpansions"];
+        readonly onColumnGroupExpansionChange: Props<Spec>["onColumnGroupExpansionChange"];
+    };
+    readonly rowUpdate: (rows: Map<RowNode<Spec["data"]>, Spec["data"]>) => void;
+    readonly rowDelete: (rows: RowNode<Spec["data"]>[]) => void;
+    readonly rowAdd: (rows: Spec["data"][], placement?: "start" | "end" | number) => void;
+}
+export type LabelFilter = (s: string | null) => boolean;
+export interface PivotModel<Spec extends GridSpec = GridSpec> {
+    readonly columns?: (Column<Spec> | PivotField<Spec>)[];
+    readonly rows?: (Column<Spec> | PivotField<Spec>)[];
+    readonly measures?: {
+        dim: Column<Spec>;
+        fn: Aggregator<Spec["data"]> | string;
+    }[];
+    readonly sort?: SortFn<Spec["data"]> | DimensionSort<Spec["data"]>[] | null;
+    readonly filter?: (HavingFilterFn | null)[];
+    readonly rowLabelFilter?: (LabelFilter | null)[];
+    readonly colLabelFilter?: (LabelFilter | null)[];
+}
+export interface UseClientDataSourceParams<Spec extends GridSpec = GridSpec, T = Spec["data"]> {
+    readonly data: T[];
+    readonly topData?: T[];
+    readonly botData?: T[];
+    readonly pivotMode?: boolean;
+    readonly pivotModel?: PivotModel<Spec>;
+    readonly pivotGrandTotals?: "top" | "bottom" | null;
+    readonly pivotColumnProcessor?: (columns: Column<Spec>[]) => Column<Spec>[];
+    readonly pivotState?: PivotState;
+    readonly onPivotStateChange?: (p: PivotState) => void;
+    readonly pivotApplyExistingFilter?: boolean;
+    readonly rowGroupExpansions?: {
+        [rowId: string]: boolean | undefined;
+    };
+    readonly rowGroupDefaultExpansion?: boolean | number;
+    readonly rowGroupCollapseBehavior?: "no-collapse" | "last-only" | "full-tree";
+    readonly rowGroupSuppressLeafExpansion?: boolean;
+    readonly onRowGroupExpansionChange?: (state: Record<string, boolean | undefined>) => void;
+    readonly sort?: SortFn<T> | DimensionSort<T>[] | null;
+    readonly group?: GroupFn<T> | Dimension<T>[];
+    readonly filter?: FilterFn<T> | FilterFn<T>[] | null;
+    readonly aggregate?: AggregationFn<T> | DimensionAgg<T>[];
+    readonly aggregateFns?: Record<string, Aggregator<T>>;
+    readonly having?: (HavingFilterFn | null)[] | null;
+    readonly labelFilter?: (LabelFilter | null)[] | null;
+    readonly leafIdFn?: LeafIdFn<T>;
+    readonly groupIdFn?: GroupIdFn;
+    readonly rowsIsolatedSelection?: boolean;
+    readonly rowSelectKey?: unknown[];
+    readonly rowSelection?: RowSelectionState;
+    readonly rowSelectionIdUniverseAdditions?: {
+        readonly id: string;
+        readonly root: boolean;
+    }[];
+    readonly rowSelectionIdUniverseSubtractions?: Set<string>;
+    readonly onRowSelectionChange?: (state: RowSelectionState) => void;
+    readonly onRowsAdded?: (params: {
+        newData: T[];
+        placement: "start" | "end" | number;
+        top: T[];
+        center: T[];
+        bottom: T[];
+    }) => void;
+    readonly onRowsDeleted?: (params: {
+        rows: RowLeaf<T>[];
+        sourceIndices: number[];
+        top: T[];
+        center: T[];
+        bottom: T[];
+    }) => void;
+    readonly onRowDataChange?: (params: {
+        readonly rows: Map<RowNode<T>, T>;
+        readonly top: Map<number, T>;
+        readonly bottom: Map<number, T>;
+        readonly center: Map<number, T>;
+    }) => void;
+}
+export declare function useClientDataSource<Spec extends GridSpec = GridSpec>(props: UseClientDataSourceParams<Spec>): RowSourceClient<Spec>;

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

@@ -0,0 +1,169 @@
+import { useMemo } from "react";
+import { useSourceState } from "./hooks/use-controlled-ds-state.js";
+import { useEvent, useGlobalRefresh, useIdUniverse, useLeafNodes, useOnRowsSelected, useOnRowsUpdated, usePiece, useRowAdd, useRowById, useRowByIndex, useRowChildren, useRowDelete, useRowIsSelected, useRowLeafs, useRowParents, useRows, useRowsBetween, useRowSelection, useRowSelectionState, useRowSelectSplitLookup, useRowSiblings, } from "@1771technologies/lytenyte-core/internal";
+import { useFlattenedData } from "./hooks/use-flattened-data.js";
+import { usePivotData } from "./hooks/use-pivot/use-pivot-data.js";
+import { usePivotState } from "./hooks/use-pivot/use-pivot-state.js";
+const groupIdFallback = (p) => p.map((x) => (x == null ? "_null_" : x)).join("->");
+export function useClientDataSource(props) {
+    const leafsTuple = useLeafNodes(props.topData, props.data, props.botData, props.leafIdFn);
+    const pivotControlled = usePivotState(props.pivotState, props.onPivotStateChange);
+    // s == state, f == flat, p == pivot
+    const s = useSourceState(props, pivotControlled);
+    const d = useFlattenedData(props, leafsTuple, s);
+    const p = usePivotData(props, leafsTuple, s, pivotControlled);
+    const f = props.pivotMode ? p : d;
+    const mode = props?.pivotMode === true;
+    const piece = usePiece(mode ? p.flatten : d.flatten);
+    const botPiece = usePiece(f.leafsBot.length);
+    const topPiece = usePiece(f.leafsTop.length);
+    const depth = props.group
+        ? Array.isArray(props.group)
+            ? props.group.length
+            : d.maxDepth
+        : props.pivotMode && props.pivotModel?.rows?.length
+            ? p.maxDepth
+            : 0;
+    const maxDepthPiece = usePiece(depth);
+    const rowById = useRowById(f.tree, f.leafIdsRef);
+    const rowParents = useRowParents(rowById, f.tree, f.groupFn, props.groupIdFn ?? groupIdFallback);
+    const onRowsUpdated = useOnRowsUpdated(props.onRowDataChange);
+    const globalSignal = useGlobalRefresh();
+    const idToSpec = useEvent((id) => {
+        if (!f.tree)
+            return null;
+        const node = f.tree.groupLookup.get(id);
+        if (!node)
+            return null;
+        return { size: node.children.size, children: node.children };
+    });
+    const rowSelectionKey = useMemo(() => {
+        if (props.rowSelectKey)
+            return props.rowSelectKey;
+        return [props.group, props.filter];
+    }, [props.filter, props.group, props.rowSelectKey]);
+    const { idUniverse, rootIds } = useIdUniverse(f.tree, f.leafIdsRef.current, props.rowSelectionIdUniverseAdditions, props.rowSelectionIdUniverseSubtractions);
+    const selectionState = useRowSelection(props.rowSelection, props.onRowSelectionChange, props.rowsIsolatedSelection ?? false, rowSelectionKey, idUniverse, rootIds, rootIds.size, globalSignal);
+    const onRowsSelected = useOnRowsSelected(selectionState, idToSpec, rowParents, props.rowsIsolatedSelection ?? false, globalSignal);
+    const rowIsSelected = useRowIsSelected(selectionState, rowParents, rowById);
+    const rowsSelected = useRowSelectSplitLookup(selectionState, f.leafIdsRef.current, f.tree?.groupLookup, rowParents);
+    const rowSelectionState = useRowSelectionState(selectionState);
+    const { rowInvalidate, rowByIndex } = useRowByIndex(piece, globalSignal, selectionState, rowParents);
+    const rowsBetween = useRowsBetween(f.rowIdToRowIndexRef, rowByIndex);
+    const rowLeafs = useRowLeafs(f.tree);
+    const rowChildren = useRowChildren(f.tree);
+    const setExpansions = s.onExpansionsChange;
+    const setPivotState = pivotControlled.onPivotColumnStateChange;
+    const setPivotGroupState = pivotControlled.onPivotGroupStateChange;
+    const setPivotRowGroupExpansions = s.onPivotExpansionsChange;
+    const mode$ = usePiece(mode);
+    const flat = piece.get();
+    const rowAdd = useRowAdd(props);
+    const rowDelete = useRowDelete(props, rowById);
+    const rows$ = useRows(flat);
+    const rowSiblings = useRowSiblings(f.tree);
+    const selection$ = usePiece(selectionState.rowSelectionsRaw);
+    const source = useMemo(() => {
+        const rowCount$ = (x) => x.length;
+        const source = {
+            rowInvalidate,
+            rowByIndex,
+            rowIndexToRowId: (index) => f.rowByIndexRef.current.get(index)?.id ?? null,
+            rowIdToRowIndex: (id) => f.rowIdToRowIndexRef.current.get(id) ?? null,
+            rowById,
+            rowsBetween,
+            rowChildren,
+            rowLeafs,
+            rowIsSelected,
+            rowsSelected,
+            rowParents,
+            rowSelectionState,
+            rowAdd,
+            rowDelete,
+            rowUpdate: onRowsUpdated,
+            rowSiblings,
+            useBottomCount: botPiece.useValue,
+            useTopCount: topPiece.useValue,
+            useRowCount: () => piece.useValue(rowCount$),
+            useRows: () => rows$.useValue(),
+            useSelectionState: selection$.useValue,
+            useMaxRowGroupDepth: maxDepthPiece.useValue,
+            rowGroupExpansionChange: (deltaChanges) => {
+                if (mode$.get())
+                    setPivotRowGroupExpansions(deltaChanges);
+                else
+                    setExpansions(deltaChanges);
+            },
+            onRowsSelected,
+            onRowsUpdated,
+            onViewChange: () => { },
+            usePivotProps: () => {
+                const pivotColumns = p.pivotPiece.useValue();
+                const pivotGroups = p.pivotGroupPiece.useValue();
+                const mode = mode$.useValue();
+                return useMemo(() => {
+                    if (!mode)
+                        return {};
+                    const object = {};
+                    if (pivotColumns)
+                        object.columns = pivotColumns;
+                    if (pivotColumns)
+                        object.columnGroupExpansions = pivotGroups.value;
+                    const onColChange = (columns) => {
+                        const ordering = columns.map((x) => x.id);
+                        const resizingEntries = columns
+                            .map((x) => (x.width == null ? null : [x.id, x.width]))
+                            .filter(Boolean);
+                        const pinnedEntries = columns
+                            .map((x) => (x.pin === undefined ? null : [x.id, x.pin]))
+                            .filter(Boolean);
+                        setPivotState({
+                            ordering,
+                            resizing: Object.fromEntries(resizingEntries),
+                            pinning: Object.fromEntries(pinnedEntries),
+                        });
+                    };
+                    const onColumnGroup = (change) => {
+                        setPivotGroupState(change);
+                    };
+                    object.onColumnsChange = onColChange;
+                    object.onColumnGroupExpansionChange = onColumnGroup;
+                    return object;
+                }, [mode, pivotColumns, pivotGroups.value]);
+            },
+        };
+        return source;
+    }, [
+        rowInvalidate,
+        rowByIndex,
+        rowById,
+        rowsBetween,
+        rowChildren,
+        rowLeafs,
+        rowIsSelected,
+        rowsSelected,
+        rowParents,
+        rowSelectionState,
+        rowAdd,
+        rowDelete,
+        onRowsUpdated,
+        rowSiblings,
+        botPiece.useValue,
+        topPiece.useValue,
+        selection$.useValue,
+        maxDepthPiece.useValue,
+        onRowsSelected,
+        f.rowByIndexRef,
+        f.rowIdToRowIndexRef,
+        piece,
+        rows$,
+        mode$,
+        setPivotRowGroupExpansions,
+        setExpansions,
+        p.pivotPiece,
+        p.pivotGroupPiece,
+        setPivotState,
+        setPivotGroupState,
+    ]);
+    return source;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,27 @@
+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/data-source-server/async-tree/apply-set-action-to-tree.d.ts

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

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

@@ -0,0 +1,26 @@
+import { maybeApplyParentRemoveSelf } from "./maybe-apply-parent-remove-self.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";
+import { checkSetAction } from "./data-integrity-checks/check-set-action.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;
+    checkSetAction(p, pathNode);
+    if (isSetActionANoOpOnNode(p, pathNode))
+        return false;
+    maybeApplyResize(pathNode, p.size, p.asOf ?? Date.now());
+    if (maybeApplyParentRemoveSelf(pathNode))
+        return true;
+    maybeApplySetActionItems(p, pathNode, root);
+    return true;
+}

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

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

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

@@ -0,0 +1,20 @@
+import { ROOT_LEAF_PREFIX } from "../+constants.async-tree.js";
+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)) {
+            return false;
+        }
+        const pathId = item.kind === "leaf" ? `${p.path.at(-1) ?? ROOT_LEAF_PREFIX}#${item.relIndex}` : item.path;
+        if (seenPaths.has(pathId)) {
+            return false;
+        }
+        seenPaths.add(pathId);
+        seenKeys.add(item.relIndex);
+    }
+    return true;
+}

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

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

package/dist/data-source-server/async-tree/data-integrity-checks/check-set-action-item-keys-are-valid.js

@@ -0,0 +1,12 @@
+export function checkSetActionItemKeysAreValid(p) {
+    if (!p.items?.length)
+        return true;
+    const items = p.items;
+    for (let i = items.length - 1; i >= 0; i--) {
+        const x = items[i];
+        if (typeof x.relIndex !== "number" || x.relIndex < 0 || Math.floor(x.relIndex) !== x.relIndex) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/data-source-server/async-tree/data-integrity-checks/check-set-action-item-keys-fit.d.ts

@@ -0,0 +1,2 @@
+import type { SetDataAction, TreeParent, TreeRoot } from "../types.js";
+export declare function checkSetActionItemKeysFit(p: SetDataAction, pathNode: TreeParent | TreeRoot): boolean;

package/dist/data-source-server/async-tree/data-integrity-checks/check-set-action-item-keys-fit.js

@@ -0,0 +1,18 @@
+const invalidItemKeySize = "Invalid set action items, 'relIndex' must be less than parent size";
+export function checkSetActionItemKeysFit(p, pathNode) {
+    // If we are not adding any items, then the items definitely fit - since 0 fits in 0.
+    if (!p.items?.length)
+        return true;
+    // Grab the node size. The action may be updating the size, so we check for that first, otherwise
+    // we check if the current size.
+    const size = p.size ?? pathNode.size;
+    // We check the relative item indices. They should be within the size.
+    for (let i = p.items.length - 1; i >= 0; i--) {
+        const x = p.items[i];
+        if (x.relIndex >= size) {
+            console.error(invalidItemKeySize, p, pathNode);
+            return false;
+        }
+    }
+    return true;
+}

package/dist/data-source-server/async-tree/data-integrity-checks/check-set-action-item-kinds.d.ts

@@ -0,0 +1,2 @@
+import type { SetDataAction } from "../types.js";
+export declare function checkSetActionItemKinds(p: SetDataAction): boolean;

package/dist/data-source-server/async-tree/data-integrity-checks/check-set-action-item-kinds.js

@@ -0,0 +1,12 @@
+export function checkSetActionItemKinds(p) {
+    if (!p.items?.length)
+        return true;
+    const items = p.items;
+    for (let i = items.length - 1; i >= 0; i--) {
+        const x = items[i];
+        if (x.kind !== "leaf" && x.kind !== "parent") {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/data-source-server/async-tree/data-integrity-checks/check-set-action.d.ts

@@ -0,0 +1,2 @@
+import type { SetDataAction, TreeParent, TreeRoot } from "../types";
+export declare function checkSetAction(p: SetDataAction, pathNode: TreeRoot | TreeParent): void;

package/dist/data-source-server/async-tree/data-integrity-checks/check-set-action.js

@@ -0,0 +1,24 @@
+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";
+export function checkSetAction(p, pathNode) {
+    // We need to make sure that the items being added will fit path nodes specification.
+    if (!checkSetActionItemKeysFit(p, pathNode)) {
+        console.error("Invalid data dispatch", p);
+        throw new Error(`Server data payload error occurred. The node at at ${p.path} has a size of ${pathNode.size} but data payload would exceed this size.`);
+    }
+    // We need to ensure the kind of the data in the dispatch is valid.
+    if (!checkSetActionItemKinds(p)) {
+        console.error("Invalid data dispatch", p);
+        throw new Error(`Server data payload error occurred. The payload has invalid data kinds. Each item must have kind "leaf" or "parent".`);
+    }
+    if (!checkSetActionItemKeysAreValid(p)) {
+        console.error("Invalid data dispatch", p);
+        throw new Error(`Server data payload error occurred. The payload has invalid relIndex values.`);
+    }
+    if (!checkSetActionItemKeysAreUnique(p)) {
+        console.error("Invalid data dispatch", p);
+        throw new Error(`Server data payload error occurred. The payload has duplicated key items or paths.`);
+    }
+}

package/dist/data-source-server/async-tree/get-parent-node-by-path.d.ts

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