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

package/dist/components/tree-view/select-all.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+import { Checkbox } from "../checkbox/checkbox.js";
+export function SelectAll({ api, render, }) {
+    const s = api.useSelectionState();
+    const selected = useMemo(() => {
+        const selected = s.selected && s.children.size === 0;
+        return selected;
+    }, [s]);
+    const indeterminate = useMemo(() => {
+        return Boolean(s.children.size);
+    }, [s]);
+    const toggle = useEvent((b) => {
+        if (b != null)
+            return api.rowSelect({ selected: "all", deselect: !b });
+        api.rowSelect({ selected: "all", deselect: selected });
+    });
+    if (render)
+        return render({ indeterminate, selected, toggle });
+    return (_jsxs("div", { "data-ln-tree-view-cell": "leaf", style: { "--ln-row-depth": 0 }, children: [_jsx(Checkbox, { checked: selected, indeterminate: indeterminate, onClick: () => toggle() }), "Select All"] }));
+}

package/dist/components/tree-view/tree-children.d.ts

@@ -0,0 +1,2 @@
+import type { TreeViewChildParams, TreeViewItem } from "./types";
+export declare function TreeChildren<T extends TreeViewItem>({ row, toggle, selectEnabled: selection, indeterminate, selected, handleSelect, dragProps, isOver, isBefore, }: TreeViewChildParams<T>): import("react/jsx-runtime").JSX.Element;

package/dist/components/tree-view/tree-children.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Checkbox } from "../checkbox/checkbox.js";
+export function TreeChildren({ row, toggle, selectEnabled: selection, indeterminate, selected, handleSelect, dragProps, isOver, isBefore, }) {
+    const depth = row.depth;
+    const draggable = !!dragProps.draggable;
+    if (row.kind === "branch")
+        return (_jsxs("div", { "data-ln-tree-view-cell": row.kind, "data-ln-tree-view-cell-expanded": row.kind === "branch" && row.expanded, "data-ln-tree-view-cell-expandable": row.kind === "branch" ? row.expandable : undefined, "data-ln-tree-over": isOver, "data-ln-tree-before": isBefore, style: { "--ln-row-depth": depth }, ...dragProps, children: [row.kind === "branch" && row.expandable && (_jsx("button", { "data-ln-tree-view-cell-expander": true, "aria-label": "toggle the row group expansion state", onClick: () => toggle(), children: !row.loadingGroup && _jsx(CaretRight, {}) })), draggable && (_jsx("div", { children: _jsx(DragDots, {}) })), selection && (_jsx(Checkbox, { checked: selected, indeterminate: indeterminate, onClick: (e) => handleSelect({ target: e.target, shiftKey: e.shiftKey }) })), _jsx("div", { children: row.key })] }));
+    return (_jsxs("div", { "data-ln-tree-view-cell": row.kind, "data-ln-tree-over": isOver, "data-ln-tree-before": isBefore, style: { "--ln-row-depth": depth }, ...dragProps, children: [draggable && (_jsx("div", { children: _jsx(DragDots, {}) })), selection && (_jsx(Checkbox, { checked: selected, indeterminate: indeterminate, onClick: (e) => handleSelect({ target: e.target, shiftKey: e.shiftKey }) })), row.data.name ?? row.data.id] }));
+}
+function CaretRight() {
+    return (_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "16", height: "16", fill: "currentcolor", viewBox: "0 0 256 256", children: _jsx("path", { d: "M181.66,133.66l-80,80A8,8,0,0,1,88,208V48a8,8,0,0,1,13.66-5.66l80,80A8,8,0,0,1,181.66,133.66Z" }) }));
+}
+function DragDots() {
+    return (_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "16", height: "16", fill: "currentcolor", viewBox: "0 0 256 256", children: _jsx("path", { d: "M104,60A12,12,0,1,1,92,48,12,12,0,0,1,104,60Zm60,12a12,12,0,1,0-12-12A12,12,0,0,0,164,72ZM92,116a12,12,0,1,0,12,12A12,12,0,0,0,92,116Zm72,0a12,12,0,1,0,12,12A12,12,0,0,0,164,116ZM92,184a12,12,0,1,0,12,12A12,12,0,0,0,92,184Zm72,0a12,12,0,1,0,12,12A12,12,0,0,0,164,184Z" }) }));
+}

package/dist/components/tree-view/types.d.ts

@@ -0,0 +1,31 @@
+import type { RowGroup, RowLeaf } from "@1771technologies/lytenyte-shared";
+import type { DragEvent } from "react";
+export interface TreeViewItem {
+    readonly id: string;
+    readonly path: string[];
+    readonly name?: string;
+}
+export interface TreeViewChildParams<T extends TreeViewItem> {
+    readonly row: RowGroup | RowLeaf<T>;
+    readonly leafs: () => T[];
+    readonly toggle: (b?: boolean) => void;
+    readonly selected: boolean;
+    readonly indeterminate: boolean;
+    readonly selectEnabled: boolean;
+    readonly select: (b?: boolean) => void;
+    readonly handleSelect: (params: {
+        readonly target: EventTarget;
+        readonly shiftKey: boolean;
+    }) => void;
+    readonly dragProps: {
+        draggable?: boolean;
+        onDragStart?: (ev: DragEvent) => void;
+    };
+    readonly isOver: boolean;
+    readonly isBefore: boolean;
+}
+export interface TreeViewSelectAllParams {
+    readonly selected: boolean;
+    readonly indeterminate: boolean;
+    readonly toggle: (b?: boolean) => void;
+}

package/dist/components/types.d.ts

@@ -0,0 +1,4 @@
+import type { SlotComponent } from "../hooks/use-slot/types";
+export type LnComponent<Props, State> = Props & {
+    render?: SlotComponent<State>;
+};

package/dist/components/virtual-from-coordinates.d.ts

@@ -0,0 +1,2 @@
+import type { VirtualTarget } from "../types";
+export declare function virtualFromXY(x: number, y: number, context?: HTMLElement): VirtualTarget;

package/dist/components/virtual-from-coordinates.js

@@ -0,0 +1,15 @@
+export function virtualFromXY(x, y, context) {
+    return {
+        contextElement: context,
+        getBoundingClientRect: () => ({
+            bottom: y,
+            left: x,
+            height: 0,
+            right: x,
+            top: y,
+            width: 0,
+            x,
+            y,
+        }),
+    };
+}

package/dist/components.d.ts

@@ -0,0 +1,16 @@
+export type { ViewportShadowsProps } from "@1771technologies/lytenyte-core/components";
+export { ViewportShadows } from "@1771technologies/lytenyte-core/components";
+export { RowGroupCell } from "./components/row-group-cell.js";
+export type { SelectAllProps } from "./components/select-all.js";
+export { SelectAll } from "./components/select-all.js";
+export { PillManager } from "./components/pill-manager/index.js";
+export { Dialog } from "./components/headless/dialog/index.parts.js";
+export { Menu } from "./components/headless/menu/index.js";
+export { Popover } from "./components/headless/popover/index.js";
+export { SmartSelect } from "./components/smart-select/index.js";
+export type { TreeViewItem, TreeViewProps, TreeViewChildParams, TreeViewSelectAllParams, } from "./components/tree-view/index.js";
+export type { TreeViewApi } from "./components/tree-view/index.js";
+export { TreeView, TreeChildren } from "./components/tree-view/index.js";
+export type { ColumnManagerProps } from "./components/column-manager/column-manager.js";
+export { ColumnManager } from "./components/column-manager/column-manager.js";
+export { Checkbox } from "./components/checkbox/checkbox.js";

package/dist/components.js

@@ -0,0 +1,11 @@
+export { ViewportShadows } from "@1771technologies/lytenyte-core/components";
+export { RowGroupCell } from "./components/row-group-cell.js";
+export { SelectAll } from "./components/select-all.js";
+export { PillManager } from "./components/pill-manager/index.js";
+export { Dialog } from "./components/headless/dialog/index.parts.js";
+export { Menu } from "./components/headless/menu/index.js";
+export { Popover } from "./components/headless/popover/index.js";
+export { SmartSelect } from "./components/smart-select/index.js";
+export { TreeView, TreeChildren } from "./components/tree-view/index.js";
+export { ColumnManager } from "./components/column-manager/column-manager.js";
+export { Checkbox } from "./components/checkbox/checkbox.js";

package/dist/data-source-client/hooks/get-valid-leafs.d.ts

@@ -0,0 +1,3 @@
+import type { RowLeaf } from "@1771technologies/lytenyte-shared";
+import type { GroupNode } from "./use-group-tree/use-group-tree";
+export declare function getValidLeafs<T>(node: GroupNode<T>, leafs: RowLeaf<T>[], workingSet: number[]): RowLeaf<any>[];

package/dist/data-source-client/hooks/get-valid-leafs.js

@@ -0,0 +1,11 @@
+export function getValidLeafs(node, leafs, workingSet) {
+    const rows = [];
+    for (let i = 0; i < node.leafs.length; i++) {
+        const x = node.leafs[i];
+        const workingIndex = workingSet[x];
+        const row = leafs[workingIndex];
+        if (node.leafIds.has(row.id))
+            rows.push(row);
+    }
+    return rows;
+}

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

@@ -0,0 +1,13 @@
+import type { UseClientDataSourceParams } from "../use-client-data-source.js";
+import type { ControlledPivotState } from "./use-pivot/use-pivot-state.js";
+export type SourceState = ReturnType<typeof useSourceState>;
+export declare function useSourceState({ onRowGroupExpansionChange, rowGroupExpansions, rowGroupDefaultExpansion, }: UseClientDataSourceParams<any>, controlled: ControlledPivotState): {
+    expansions: {
+        [rowId: string]: boolean | undefined;
+    };
+    onExpansionsChange: (delta: Record<string, boolean | undefined>) => void;
+    expandedFn: (id: string, depth: number) => boolean;
+    pivotExpandedFn: (id: string, depth: number) => boolean;
+    pivotRowGroupExpansions: Record<string, boolean | undefined>;
+    onPivotExpansionsChange: (delta: Record<string, boolean | undefined>) => void;
+};

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

@@ -0,0 +1,39 @@
+import { useCallback } from "react";
+import { useControlled, useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useSourceState({ onRowGroupExpansionChange, rowGroupExpansions, rowGroupDefaultExpansion = false, }, controlled) {
+    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]);
+    const onPivotExpansionsChange = useEvent((delta) => {
+        controlled.onPivotRowGroupChange({ ...controlled.pivotRowGroupExpansions, ...delta });
+    });
+    const pivotExpandedFn = useCallback((id, depth) => {
+        const s = controlled.pivotRowGroupExpansions[id];
+        if (s != null)
+            return s;
+        if (typeof rowGroupDefaultExpansion === "boolean")
+            return rowGroupDefaultExpansion;
+        return rowGroupDefaultExpansion >= depth;
+    }, [controlled.pivotRowGroupExpansions, rowGroupDefaultExpansion]);
+    return {
+        expansions,
+        onExpansionsChange,
+        expandedFn,
+        pivotExpandedFn,
+        pivotRowGroupExpansions: controlled.pivotRowGroupExpansions,
+        onPivotExpansionsChange,
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { GridSpec } from "../../types/grid.js";
+import type { UseClientDataSourceParams } from "../use-client-data-source.js";
+import type { SourceState } from "./use-controlled-ds-state.js";
+import { type LeafNodeTuple } from "@1771technologies/lytenyte-core/internal";
+export declare function useFlattenedData<Spec extends GridSpec>(props: UseClientDataSourceParams<Spec>, [leafsTop, leafs, leafsBot, pinMap]: LeafNodeTuple<Spec["data"]>, { expandedFn }: SourceState): {
+    tree: import("./use-group-tree/use-group-tree.js").RootNode<Spec["data"]> | null;
+    maxDepth: number;
+    flatten: import("@1771technologies/lytenyte-shared").RowNode<Spec["data"]>[];
+    rowByIdRef: import("react").RefObject<Map<string, import("@1771technologies/lytenyte-shared").RowNode<Spec["data"]>>>;
+    rowByIndexRef: import("react").RefObject<Map<number, import("@1771technologies/lytenyte-shared").RowNode<Spec["data"]>>>;
+    rowIdToRowIndexRef: import("react").RefObject<Map<string, number>>;
+    leafIdsRef: import("react").RefObject<Map<string, import("@1771technologies/lytenyte-shared").RowLeaf<Spec["data"]>>>;
+    leafsTop: import("@1771technologies/lytenyte-shared").RowLeaf<Spec["data"]>[];
+    leafs: import("@1771technologies/lytenyte-shared").RowLeaf<Spec["data"]>[];
+    leafsBot: import("@1771technologies/lytenyte-shared").RowLeaf<Spec["data"]>[];
+    sorted: number[];
+    groupFn: import("@1771technologies/lytenyte-shared").GroupFn<Spec["data"]> | null;
+};

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

@@ -0,0 +1,40 @@
+import { useGroupTree } from "./use-group-tree/use-group-tree.js";
+import { useFlattenedGroups } from "./use-flattened-groups.js";
+import { useFlattenedPiece } from "./use-flattened-piece.js";
+import { useAggregationFn, useFiltered, useFilterFn, useGroupFn, useSorted, useSortFn, } from "@1771technologies/lytenyte-core/internal";
+import { useMemo, useRef } from "react";
+const groupIdFallback = (p) => p.map((x) => (x == null ? "_null_" : x)).join("->");
+export function useFlattenedData(props, [leafsTop, leafs, leafsBot, pinMap], { expandedFn }) {
+    const filterFn = useFilterFn(props.filter);
+    const sortFn = useSortFn(props.sort);
+    const groupFn = useGroupFn(props.group);
+    const aggFn = useAggregationFn(props.aggregate, props.aggregateFns);
+    const filtered = useFiltered(leafs, filterFn);
+    const [sorted, centerMap] = useSorted(leafs, sortFn, filtered);
+    const leafIds = useMemo(() => new Map([...centerMap, ...pinMap]), [centerMap, pinMap]);
+    const leafIdsRef = useRef(leafIds);
+    leafIdsRef.current = leafIds;
+    const tree = useGroupTree(leafs, sorted, groupFn, props.groupIdFn ?? groupIdFallback, props.rowGroupCollapseBehavior ?? "no-collapse", props.labelFilter, props.having, aggFn);
+    const [groupFlat, maxDepth] = useFlattenedGroups(tree, aggFn, leafs, sorted, sortFn, expandedFn, props.rowGroupSuppressLeafExpansion ?? false);
+    const { flatten, rowByIdRef, rowByIndexRef, rowIdToRowIndexRef } = useFlattenedPiece({
+        leafsTop,
+        leafsCenter: leafs,
+        leafsBot,
+        groupFlat,
+        centerIndices: sorted,
+    });
+    return {
+        tree,
+        maxDepth,
+        flatten,
+        rowByIdRef,
+        rowByIndexRef,
+        rowIdToRowIndexRef,
+        leafIdsRef,
+        leafsTop,
+        leafs,
+        leafsBot,
+        sorted,
+        groupFn,
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { AggregationFn, RowLeaf, RowNode, SortFn } from "@1771technologies/lytenyte-shared";
+import type { RootNode } from "./use-group-tree/use-group-tree";
+type UseFlattenedGroupsReturn<T> = [rows: RowNode<T>[] | null, depth: number];
+export declare function useFlattenedGroups<T>(root: RootNode<T> | null, agg: AggregationFn<T> | undefined | null, leafs: RowLeaf<T>[], workingSet: number[], sort: SortFn<T> | null | undefined, expandedFn: (id: string, depth: number) => boolean, suppressLeafExpansion: boolean, ignoreIsLast?: boolean): UseFlattenedGroupsReturn<T>;
+export {};

package/dist/data-source-client/hooks/use-flattened-groups.js

@@ -0,0 +1,63 @@
+import { useMemo } from "react";
+import { getValidLeafs } from "./get-valid-leafs.js";
+import { useSortFn } from "@1771technologies/lytenyte-core/internal";
+export function useFlattenedGroups(root, agg, leafs, workingSet, sort, expandedFn, suppressLeafExpansion, ignoreIsLast = false) {
+    const sortFallbackDim = useMemo(() => [{ dim: { id: "__ln_group__" } }], []);
+    const sortFallback = useSortFn(sortFallbackDim);
+    const flat = useMemo(() => {
+        if (!root)
+            return [null, 0];
+        const flatList = [];
+        const ranges = [];
+        let maxDepth = 0;
+        function processRowsBetter(node, parent, start, isLast, depth = 0) {
+            maxDepth = Math.max(depth + 1, maxDepth);
+            const rows = nodeChildrenToRows(node, agg, leafs, workingSet, sort ?? sortFallback, isLast && !ignoreIsLast);
+            let offset = 0;
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                const rowIndex = i + start + offset;
+                if (row.kind === "leaf") {
+                    flatList.push(row);
+                    continue;
+                }
+                flatList.push(row);
+                const notExpandable = suppressLeafExpansion && row.last;
+                row.expandable = !notExpandable;
+                if (!expandedFn(row.id, depth) || notExpandable) {
+                    row.expanded = false;
+                    continue;
+                }
+                row.expanded = true;
+                offset += processRowsBetter(row.__children, row, rowIndex + 1, row.last, depth + 1);
+            }
+            ranges.push({ parent, start, end: offset + start + node.size });
+            return offset + node.size;
+        }
+        processRowsBetter(root.children, null, 0, root.maxDepth <= 1);
+        return [flatList, maxDepth];
+    }, [agg, expandedFn, ignoreIsLast, leafs, root, sort, sortFallback, suppressLeafExpansion, workingSet]);
+    return flat;
+}
+const nodeChildrenToRows = (root, agg, leafs, workingSet, sort, isLast) => {
+    const values = root.values();
+    const rows = [];
+    for (const v of values) {
+        if (v.kind === "leaf") {
+            rows.push(v.row);
+            continue;
+        }
+        else {
+            const row = v.row;
+            if (row.__invalidate) {
+                const data = agg ? agg(getValidLeafs(v, leafs, workingSet)) : {};
+                row.data = data;
+                row.__invalidate = false;
+            }
+            rows.push(row);
+        }
+    }
+    if (!isLast && sort)
+        return rows.sort(sort);
+    return rows;
+};

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

@@ -0,0 +1,14 @@
+import type { RowNode } from "@1771technologies/lytenyte-shared";
+export interface UseFlattenedPieceParams<T> {
+    leafsTop: RowNode<T>[];
+    leafsCenter: RowNode<T>[];
+    leafsBot: RowNode<T>[];
+    groupFlat: RowNode<T>[] | null;
+    centerIndices: number[];
+}
+export declare function useFlattenedPiece<T>({ leafsTop, leafsCenter, leafsBot, groupFlat, centerIndices, }: UseFlattenedPieceParams<T>): {
+    flatten: RowNode<T>[];
+    rowByIdRef: import("react").RefObject<Map<string, RowNode<T>>>;
+    rowByIndexRef: import("react").RefObject<Map<number, RowNode<T>>>;
+    rowIdToRowIndexRef: import("react").RefObject<Map<string, number>>;
+};

package/dist/data-source-client/hooks/use-flattened-piece.js

@@ -0,0 +1,55 @@
+import { useMemo, useRef } from "react";
+export function useFlattenedPiece({ leafsTop, leafsCenter, leafsBot, groupFlat, centerIndices, }) {
+    const rowByIdRef = useRef(null);
+    const rowByIndexRef = useRef(null);
+    const rowIdToRowIndexRef = useRef(null);
+    const [flatten] = useMemo(() => {
+        const flat = [];
+        const byId = new Map();
+        const byIndex = new Map();
+        const byIdToIndex = new Map();
+        for (let i = 0; i < leafsTop.length; i++) {
+            const node = leafsTop[i];
+            flat.push(node);
+            byIndex.set(i, node);
+            byId.set(node.id, node);
+            byIdToIndex.set(node.id, i);
+        }
+        const offset = leafsTop.length;
+        if (groupFlat) {
+            for (let i = 0; i < groupFlat.length; i++) {
+                const rowIndex = i + offset;
+                const node = groupFlat[i];
+                flat.push(node);
+                byIndex.set(rowIndex, node);
+                byId.set(node.id, node);
+                byIdToIndex.set(node.id, rowIndex);
+            }
+        }
+        else {
+            for (let i = 0; i < centerIndices.length; i++) {
+                const rowIndex = i + offset;
+                const srcIndex = centerIndices[i];
+                const node = leafsCenter[srcIndex];
+                flat.push(node);
+                byIndex.set(rowIndex, node);
+                byId.set(node.id, node);
+                byIdToIndex.set(node.id, rowIndex);
+            }
+        }
+        const botOffset = offset + (groupFlat ? groupFlat.length : centerIndices.length);
+        for (let i = 0; i < leafsBot.length; i++) {
+            const rowIndex = i + botOffset;
+            const node = leafsBot[i];
+            flat.push(node);
+            byIndex.set(rowIndex, node);
+            byId.set(node.id, node);
+            byIdToIndex.set(node.id, rowIndex);
+        }
+        rowByIdRef.current = byId;
+        rowByIndexRef.current = byIndex;
+        rowIdToRowIndexRef.current = byIdToIndex;
+        return [flat];
+    }, [centerIndices, groupFlat, leafsBot, leafsCenter, leafsTop]);
+    return { flatten, rowByIdRef, rowByIndexRef, rowIdToRowIndexRef };
+}

package/dist/data-source-client/hooks/use-group-tree/collapse-child.d.ts

@@ -0,0 +1,2 @@
+import type { GroupNode } from "./use-group-tree.js";
+export declare const collapseChild: <T>(node: GroupNode<T>) => GroupNode<T> | import("./use-group-tree.js").LeafNode<T>;

package/dist/data-source-client/hooks/use-group-tree/collapse-child.js

@@ -0,0 +1,11 @@
+export const collapseChild = (node) => {
+    const onlyChild = node.children.values().next().value;
+    const parentKey = node.key;
+    const parent = node.parent;
+    parent.children.set(parentKey, onlyChild);
+    Object.assign(onlyChild, { parent, key: parentKey });
+    const n = onlyChild.row;
+    n.parentId = parent.kind === "root" ? null : parent.id;
+    n.depth--;
+    return onlyChild;
+};

package/dist/data-source-client/hooks/use-group-tree/collapse-last.d.ts

@@ -0,0 +1,2 @@
+import type { GroupNode, LeafNode } from "./use-group-tree.js";
+export declare const collapseLast: <T>(node: GroupNode<T> | LeafNode<T>) => void;

package/dist/data-source-client/hooks/use-group-tree/collapse-last.js

@@ -0,0 +1,14 @@
+import { collapseChild } from "./collapse-child.js";
+export const collapseLast = (node) => {
+    if (node.kind === "leaf")
+        return;
+    if (node.last) {
+        if (node.children.size === 1)
+            collapseChild(node);
+        return;
+    }
+    const values = node.children.values();
+    for (const v of values) {
+        collapseLast(v);
+    }
+};

package/dist/data-source-client/hooks/use-group-tree/collapse.d.ts

@@ -0,0 +1,2 @@
+import type { GroupNode, LeafNode } from "./use-group-tree.js";
+export declare const collapse: <T>(node: GroupNode<T> | LeafNode<T>) => void;

package/dist/data-source-client/hooks/use-group-tree/collapse.js

@@ -0,0 +1,17 @@
+import { collapseChild } from "./collapse-child.js";
+export const collapse = (node) => {
+    if (node.kind === "leaf")
+        return;
+    // This node has multiple children. For each child we should call collapse, but this node
+    // itself will not be collapsed.
+    if (node.children.size > 1) {
+        const values = node.children.values();
+        for (const v of values) {
+            collapse(v);
+        }
+        return;
+    }
+    // If we've reached here it means that this node has a single child. This means we need to
+    // replace it in its parent.
+    collapse(collapseChild(node));
+};

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

@@ -0,0 +1,31 @@
+import type { AggregationFn, GroupFn, GroupIdFn, RowGroup, RowLeaf } from "@1771technologies/lytenyte-shared";
+import type { HavingFilterFn, LabelFilter } from "../../use-client-data-source.js";
+export interface RootNode<T> {
+    readonly kind: "root";
+    readonly children: RootMap<T>;
+    readonly groupLookup: Map<string, GroupNode<T>>;
+    readonly maxDepth: number;
+}
+export interface LeafNode<T> {
+    readonly parent: GroupNode<T> | RootNode<T>;
+    readonly kind: "leaf";
+    readonly key: string | null | number;
+    readonly row: RowLeaf<T>;
+}
+export interface GroupNode<T> {
+    readonly kind: "branch";
+    readonly id: string;
+    readonly row: RowGroup & {
+        __children: Map<string | null | number, GroupNode<T> | LeafNode<T>>;
+        __invalidate: boolean;
+    };
+    readonly last: boolean;
+    readonly key: string | null | number;
+    readonly children: Map<string | null | number, GroupNode<T> | LeafNode<T>>;
+    readonly path: (string | null)[];
+    readonly leafs: number[];
+    leafIds: Set<string>;
+    readonly parent: GroupNode<T> | RootNode<T>;
+}
+export type RootMap<T> = Map<string | null | number, GroupNode<T> | LeafNode<T>>;
+export declare function useGroupTree<T>(leafs: RowLeaf<T>[], workingSet: number[], group: GroupFn<T> | undefined | null, groupIdFn: GroupIdFn, rowGroupCollapseBehavior: "no-collapse" | "last-only" | "full-tree", labelFilter: (LabelFilter | null)[] | null | undefined, having: (HavingFilterFn | null)[] | null | undefined, agg: AggregationFn<T> | undefined | null): RootNode<T> | null;