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

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

@@ -0,0 +1,152 @@
+import { useMemo, useRef } from "react";
+import { collapse } from "./collapse.js";
+import { collapseLast } from "./collapse-last.js";
+import { evaluateLabelFilter } from "../use-pivot/auxiliary-functions/evaluate-label-filter.js";
+import { getValidLeafs } from "../get-valid-leafs.js";
+export function useGroupTree(leafs, workingSet, group, groupIdFn, rowGroupCollapseBehavior, labelFilter, having, agg) {
+    const groupNodeCacheRef = useRef(new Map());
+    const prevCollapse = useRef(rowGroupCollapseBehavior);
+    if (prevCollapse.current !== rowGroupCollapseBehavior) {
+        groupNodeCacheRef.current = new Map();
+        prevCollapse.current = rowGroupCollapseBehavior;
+    }
+    return useMemo(() => {
+        const groupIdToGroupNode = new Map();
+        if (!group)
+            return null;
+        const root = {
+            kind: "root",
+            children: new Map(),
+            groupLookup: groupIdToGroupNode,
+            maxDepth: 0,
+        };
+        for (let i = 0; i < workingSet.length; i++) {
+            const n = leafs[workingSet[i]];
+            const paths = group(n);
+            // Skip this row if its path is filtered out.
+            if (!evaluateLabelFilter(labelFilter, paths))
+                continue;
+            let current = root.children;
+            let currentGroup = root;
+            // This has been marked a non-terminal node
+            if (!paths?.length) {
+                current.set(current.size, { kind: "leaf", row: n, parent: root, key: current.size });
+                continue;
+            }
+            root.maxDepth = Math.max(paths.length, root.maxDepth);
+            for (let j = 0; j < paths.length; j++) {
+                const p = paths[j];
+                if (!current.has(p)) {
+                    const partial = paths.slice(0, j + 1);
+                    const groupId = groupIdFn(partial);
+                    const children = new Map();
+                    const isLast = j === paths.length - 1;
+                    if (!groupNodeCacheRef.current.get(groupId))
+                        groupNodeCacheRef.current.set(groupId, {
+                            __children: children,
+                            __invalidate: true,
+                            last: isLast,
+                            kind: "branch",
+                            id: groupId,
+                            data: null,
+                            depth: j,
+                            key: p,
+                            parentId: currentGroup.kind === "root" ? null : currentGroup.id,
+                            expandable: false,
+                            expanded: false,
+                        });
+                    const node = groupNodeCacheRef.current.get(groupId);
+                    node.__children = children;
+                    node.__invalidate = true;
+                    node.last = isLast;
+                    node.parentId = currentGroup.kind === "root" ? null : currentGroup.id;
+                    current.set(p, {
+                        id: groupId,
+                        row: node,
+                        kind: "branch",
+                        children,
+                        leafs: [],
+                        leafIds: new Set(),
+                        path: partial,
+                        last: j === paths.length - 1,
+                        parent: currentGroup,
+                        key: p,
+                    });
+                    groupIdToGroupNode.set(groupId, current.get(p));
+                }
+                const node = current.get(p);
+                if (node.kind !== "branch") {
+                    console.error(`Invalid grouping path. Expected a group node for path: ${paths}, but found a leaf along the way.`, node);
+                    continue;
+                }
+                node.leafs.push(i);
+                node.leafIds.add(n.id);
+                currentGroup = node;
+                current = node.children;
+            }
+            const n_writable = n;
+            if (currentGroup.kind === "root") {
+                n_writable.depth = 0;
+                n_writable.parentId = null;
+            }
+            else {
+                n_writable.depth = currentGroup.row.depth + 1;
+                n_writable.parentId = currentGroup.id;
+            }
+            current.set(current.size, { kind: "leaf", row: n, parent: currentGroup, key: current.size });
+        }
+        // Doing filtering here. Then I can collapse afterwards
+        // TODO: @lee verify this logic is sound and test thoroughly
+        if (having) {
+            const traverse = (node, depth = 0) => {
+                if (node.kind === "leaf")
+                    return;
+                if (node.kind === "branch") {
+                    node.children.forEach((x) => {
+                        if (x.kind === "leaf")
+                            return;
+                        traverse(x, depth + 1);
+                    });
+                    if (node.leafIds.size === 0) {
+                        // Delete self
+                        node.parent.children.delete(node.key);
+                        return;
+                    }
+                    // Now we have traversed the group.
+                    const filterFn = Array.isArray(having) ? (having[depth] ?? null) : having;
+                    // We aren't filtering at this depth, so return early.
+                    if (!filterFn)
+                        return;
+                    const row = node.row;
+                    // We need to aggregate this row.
+                    if (row.__invalidate) {
+                        const data = agg ? agg(getValidLeafs(node, leafs, workingSet)) : {};
+                        row.data = data;
+                        row.__invalidate = false;
+                    }
+                    const shouldKeep = filterFn(row);
+                    if (shouldKeep)
+                        return;
+                    // We need to remove this row, remove the leafs from the parents going upwards.
+                    root.groupLookup.delete(node.id);
+                    node.parent.children.delete(node.key);
+                    if (node.parent.kind !== "root") {
+                        let current = node.parent;
+                        while (current) {
+                            current.leafIds = current.leafIds.difference(node.leafIds);
+                            if (current.parent.kind === "root")
+                                break;
+                            current = current.parent;
+                        }
+                    }
+                }
+            };
+            root.children.forEach((x) => traverse(x, 0));
+        }
+        if (rowGroupCollapseBehavior === "full-tree")
+            root.children.forEach(collapse);
+        if (rowGroupCollapseBehavior === "last-only")
+            root.children.forEach(collapseLast);
+        return root;
+    }, [agg, group, groupIdFn, having, labelFilter, leafs, rowGroupCollapseBehavior, workingSet]);
+}

package/dist/data-source-client/hooks/use-pivot/auxiliary-functions/apply-reference-column.d.ts

@@ -0,0 +1,2 @@
+import type { Column, GridSpec } from "../../../../types/index.js";
+export declare function applyReferenceColumn<Spec extends GridSpec>(pivotColumn: Column<Spec>, reference: Omit<Column<Spec>, "id"> | undefined): Column<Spec>;

package/dist/data-source-client/hooks/use-pivot/auxiliary-functions/apply-reference-column.js

@@ -0,0 +1,22 @@
+const omitKeys = [
+    "id",
+    "name",
+    "groupVisibility",
+    "groupPath",
+    "pin",
+    "hide",
+    "field",
+    "colSpan",
+    "rowSpan",
+    "editOnPrintable",
+    "editRenderer",
+    "editable",
+    "editSetter",
+];
+export function applyReferenceColumn(pivotColumn, reference) {
+    if (!reference)
+        return pivotColumn;
+    const final = Object.fromEntries(Object.entries(reference).filter((x) => !omitKeys.includes(x[0])));
+    Object.assign(pivotColumn, final);
+    return pivotColumn;
+}

package/dist/data-source-client/hooks/use-pivot/auxiliary-functions/evaluate-label-filter.d.ts

@@ -0,0 +1,2 @@
+import type { LabelFilter } from "../../../use-client-data-source";
+export declare function evaluateLabelFilter(labelFilter: null | undefined | (LabelFilter | null)[], path: (string | null)[] | null): boolean;

package/dist/data-source-client/hooks/use-pivot/auxiliary-functions/evaluate-label-filter.js

@@ -0,0 +1,9 @@
+export function evaluateLabelFilter(labelFilter, path) {
+    if (!labelFilter?.length || !path?.length)
+        return true;
+    return labelFilter.every((f, i) => {
+        if (!f || i >= path.length)
+            return true;
+        return f(path[i]);
+    });
+}

package/dist/data-source-client/hooks/use-pivot/auxiliary-functions/pivot-paths-with-totals.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Adds ln__total rows at every dimension level (except the measure/leaf),
+ * plus ln__grand_total rows at the top level, for every distinct leaf.
+ *
+ * Rules:
+ * - Paths are split by "-->" (whitespace around segments is trimmed).
+ * - The last segment is treated as the "leaf" (e.g., measure name).
+ * - For every prefix group, we add a total row by replacing the next segment
+ *   with ln__total and then appending the leaf.
+ *   Example: A-->B-->C-->Leaf
+ *     - A-->B-->ln__total-->Leaf     (totals across C within A,B)
+ *     - A-->ln__total-->Leaf         (totals across B,C within A)
+ * - For each distinct leaf, we add ln__grand_total-->Leaf.
+ * - Output is ordered alphabetically (case-insensitive) within each group,
+ *   with ln__total rows placed after non-total rows at the same grouping level,
+ *   and ln__grand_total rows at the end.
+ */
+export declare function pivotPathsWithTotals(paths: string[], measures: string[]): string[];

package/dist/data-source-client/hooks/use-pivot/auxiliary-functions/pivot-paths-with-totals.js

@@ -0,0 +1,140 @@
+/**
+ * Adds ln__total rows at every dimension level (except the measure/leaf),
+ * plus ln__grand_total rows at the top level, for every distinct leaf.
+ *
+ * Rules:
+ * - Paths are split by "-->" (whitespace around segments is trimmed).
+ * - The last segment is treated as the "leaf" (e.g., measure name).
+ * - For every prefix group, we add a total row by replacing the next segment
+ *   with ln__total and then appending the leaf.
+ *   Example: A-->B-->C-->Leaf
+ *     - A-->B-->ln__total-->Leaf     (totals across C within A,B)
+ *     - A-->ln__total-->Leaf         (totals across B,C within A)
+ * - For each distinct leaf, we add ln__grand_total-->Leaf.
+ * - Output is ordered alphabetically (case-insensitive) within each group,
+ *   with ln__total rows placed after non-total rows at the same grouping level,
+ *   and ln__grand_total rows at the end.
+ */
+export function pivotPathsWithTotals(paths, measures) {
+    const SEP = "-->";
+    const TOTAL = "ln__total";
+    const GRAND = "ln__grand_total";
+    // ---- Parse + normalize ----
+    const parsed = paths
+        .map((p) => p
+        .split(SEP)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0))
+        .filter((parts) => parts.length >= 2); // need at least [dim, leaf]
+    if (parsed.length === 0)
+        return [];
+    // Leaf is always last segment
+    const leaves = new Set();
+    for (const parts of parsed)
+        leaves.add(parts[parts.length - 1]);
+    // Use a Set for de-duping output
+    const out = new Set();
+    // Always include original paths (normalized)
+    for (const parts of parsed)
+        out.add(parts.join(SEP));
+    // ---- Build totals at every dimension level (except the leaf) ----
+    //
+    // For a path: d0 -> d1 -> ... -> d(n-2) -> leaf
+    // We add totals at levels i = n-2 down to 1, producing:
+    //   d0 -> ... -> d(i-1) -> TOTAL -> leaf
+    //
+    // (No group-total at level 0, since that's the grand total.)
+    const prefixesByLenAndLeaf = new Map();
+    // key: `${i}|${leaf}` where i is the prefix length (number of dims to keep, >=1)
+    // value: set of serialized prefixes (dims only, no leaf)
+    for (const parts of parsed) {
+        const leaf = parts[parts.length - 1];
+        const dims = parts.slice(0, -1); // all but leaf
+        // Consider all prefix lengths from 1..dims.length (we'll add totals below the prefix)
+        // For totals we need at least 1 kept dim, and at least one dim below it to total across.
+        // Example: dims length = 1 => no per-group totals possible.
+        for (let keep = 1; keep < dims.length; keep++) {
+            const prefix = dims.slice(0, keep).join(SEP);
+            const k = `${keep}|${leaf}`;
+            if (!prefixesByLenAndLeaf.has(k))
+                prefixesByLenAndLeaf.set(k, new Set());
+            prefixesByLenAndLeaf.get(k).add(prefix);
+        }
+    }
+    // Create total rows
+    for (const [key, prefixes] of prefixesByLenAndLeaf.entries()) {
+        const [, leaf] = key.split("|");
+        for (const prefix of prefixes) {
+            out.add(`${prefix}${SEP}${TOTAL}${SEP}${leaf}`);
+        }
+    }
+    // Also add "top level totals" like: d0 -> TOTAL -> leaf
+    // This is already covered by keep=1 when dims.length >= 2.
+    // ---- Grand totals per leaf ----
+    for (const leaf of leaves) {
+        out.add(`${GRAND}${SEP}${leaf}`);
+    }
+    // ---- Sorting rules ----
+    // We want:
+    // - Alphabetical ordering (case-insensitive) at each level
+    // - ln__total should come after normal values at the same level
+    // - ln__grand_total should come last overall
+    //
+    // We'll implement a comparator over the whole path that enforces:
+    // 1) GRAND always last
+    // 2) Otherwise compare segment-by-segment:
+    //    - At any segment, non-TOTAL comes before TOTAL
+    //    - Then alphabetical (case-insensitive), with a stable tie-breaker on raw
+    // 3) If one path is prefix of another, shorter first
+    const sortKey = (seg) => {
+        if (seg === TOTAL)
+            return [1, seg.toLowerCase(), seg];
+        return [0, seg.toLowerCase(), seg];
+    };
+    const tieIndex = Object.fromEntries(measures.map((x, i) => [x.toLowerCase(), i]));
+    const cmp = (a, b) => {
+        const aParts = a.split(SEP).map((s) => s.trim());
+        const bParts = b.split(SEP).map((s) => s.trim());
+        const aIsGrand = aParts[0] === GRAND;
+        const bIsGrand = bParts[0] === GRAND;
+        if (aIsGrand && !bIsGrand)
+            return 1;
+        if (!aIsGrand && bIsGrand)
+            return -1;
+        const len = Math.max(aParts.length, bParts.length);
+        for (let i = 0; i < len; i++) {
+            const as = aParts[i];
+            const bs = bParts[i];
+            if (as === undefined)
+                return -1;
+            if (bs === undefined)
+                return 1;
+            const ak = sortKey(as);
+            const bk = sortKey(bs);
+            // total positioning
+            if (ak[0] !== bk[0])
+                return ak[0] - bk[0];
+            // Tie break at leaf
+            if (i === aParts.length - 1 && i === bParts.length - 1) {
+                const left = tieIndex[ak[1]];
+                const right = tieIndex[bk[1]];
+                if (left < right)
+                    return -1;
+                if (left > right)
+                    return 1;
+            }
+            // case-insensitive alphabetical
+            if (ak[1] < bk[1])
+                return -1;
+            if (ak[1] > bk[1])
+                return 1;
+            // raw tie-breaker
+            if (ak[2] < bk[2])
+                return -1;
+            if (ak[2] > bk[2])
+                return 1;
+        }
+        return 0;
+    };
+    return Array.from(out).sort(cmp);
+}

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

@@ -0,0 +1,4 @@
+import type { RowLeaf } from "@1771technologies/lytenyte-shared";
+import type { PivotModel } from "../../../use-client-data-source";
+import type { GridSpec } from "../../../../types/index.js";
+export declare function pivotPaths<Spec extends GridSpec>(filtered: number[], leafs: RowLeaf<Spec["data"]>[], columns: Required<PivotModel<Spec>>["columns"], measures: PivotModel<Spec>["measures"], labelFilter: PivotModel<Spec>["colLabelFilter"]): string[];

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

@@ -0,0 +1,31 @@
+import { computeField } from "@1771technologies/lytenyte-core/internal";
+import { pivotPathsWithTotals } from "./pivot-paths-with-totals.js";
+export function pivotPaths(filtered, leafs, columns, measures, labelFilter) {
+    const pathSet = new Set();
+    for (let i = 0; i < filtered.length; i++) {
+        const row = leafs[filtered[i]];
+        const current = [];
+        for (let j = 0; j < columns.length; j++) {
+            const c = columns[j];
+            const filterFn = labelFilter?.[j];
+            const field = c.field ?? c.id;
+            const value = field ? computeField(field, row) : null;
+            if (filterFn && !filterFn(value === null ? value : String(value)))
+                continue;
+            const pivotKey = value == null ? "ln__blank__" : String(value);
+            current.push(pivotKey);
+        }
+        if (measures?.length) {
+            for (const measure of measures) {
+                pathSet.add([...current, measure.dim.id].join("-->"));
+            }
+        }
+        else {
+            current.push("ln__noop");
+            pathSet.add(current.join("-->"));
+        }
+    }
+    const paths = [...pathSet];
+    const pathsWithTotals = pivotPathsWithTotals(paths, measures?.map((x) => x.dim.id) ?? []);
+    return pathsWithTotals;
+}

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

@@ -0,0 +1,4 @@
+import type { Column, GridSpec } from "../../../types/index.js";
+import type { PivotModel } from "../../use-client-data-source.js";
+import type { AggregationFn, Aggregator } from "@1771technologies/lytenyte-shared";
+export declare function usePivotAggFunction<Spec extends GridSpec>(pivotColumns: Column<Spec>[] | null, model: PivotModel<Spec> | undefined, aggs?: Record<string, Aggregator<Spec["data"]>>): AggregationFn<Spec["data"]> | null;

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

@@ -0,0 +1,45 @@
+import { useMemo } from "react";
+import { computeField } from "@1771technologies/lytenyte-core/internal";
+const pivotAggs = {};
+export function usePivotAggFunction(pivotColumns, model, aggs = pivotAggs) {
+    const measures = model?.measures;
+    const columns = model?.columns;
+    const aggFn = useMemo(() => {
+        if (!measures?.length)
+            return null;
+        if (!pivotColumns?.length || !columns?.length)
+            return (rows) => {
+                const aggResult = {};
+                for (const m of measures) {
+                    const id = m.dim.id;
+                    const fn = typeof m.fn === "string" ? aggs[m.fn] : m.fn;
+                    if (!fn) {
+                        console.error(`Measure "${fn}" is not defined.`);
+                    }
+                    aggResult[id] = fn(m.dim.field ?? id, rows);
+                }
+                return aggResult;
+            };
+        const lookup = Object.fromEntries((measures ?? []).map((x) => [x.dim.id, x]));
+        return (rows) => {
+            const aggResult = {};
+            for (let i = 0; i < pivotColumns.length; i++) {
+                const column = pivotColumns[i];
+                const measureId = column.id.split("-->").at(-1);
+                if (measureId === "ln__noop")
+                    break;
+                const finalLeafs = rows.filter((x) => computeField(column.field, x));
+                if (finalLeafs.length) {
+                    const measure = lookup[measureId];
+                    const fn = typeof measure.fn === "string" ? aggs[measure.fn] : measure.fn;
+                    aggResult[column.id] = fn(measure.dim.field ?? measure.dim.id, finalLeafs);
+                }
+                else {
+                    aggResult[column.id] = null;
+                }
+            }
+            return aggResult;
+        };
+    }, [aggs, columns?.length, measures, pivotColumns]);
+    return aggFn;
+}

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

@@ -0,0 +1,2 @@
+import type { FilterFn, RowLeaf } from "@1771technologies/lytenyte-shared";
+export declare function useFilteredData<T>(pivotMode: boolean, filter: FilterFn<T> | undefined | null, leafs: RowLeaf<T>[]): number[];

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

@@ -0,0 +1,18 @@
+import { useMemo } from "react";
+export function useFilteredData(pivotMode, filter, leafs) {
+    // We now have our filtered
+    const filtered = useMemo(() => {
+        if (!pivotMode)
+            return [];
+        if (!filter)
+            return Array.from({ length: leafs.length }, (_, i) => i);
+        const filtered = [];
+        for (let i = 0; i < leafs.length; i++) {
+            const node = leafs[i];
+            if (filter(node))
+                filtered.push(i);
+        }
+        return filtered;
+    }, [filter, leafs, pivotMode]);
+    return filtered;
+}

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

@@ -0,0 +1,14 @@
+import type { PivotModel } from "../../use-client-data-source";
+import type { Column, GridSpec } from "../../../types/index.js";
+import { type ColumnPin, type RowLeaf } from "@1771technologies/lytenyte-shared";
+import type { ControlledPivotState } from "./use-pivot-state";
+export interface PivotState {
+    readonly columnState: {
+        readonly ordering: string[];
+        readonly resizing: Record<string, number>;
+        readonly pinning: Record<string, ColumnPin>;
+    };
+    readonly columnGroupState: Record<string, boolean>;
+    readonly rowGroupExpansions: Record<string, boolean | undefined>;
+}
+export declare function usePivotColumns<Spec extends GridSpec = GridSpec>(pivotMode: boolean, pivotControlled: ControlledPivotState, model: PivotModel<Spec> | undefined, leafs: RowLeaf<Spec["data"]>[], filtered: number[], processor: null | undefined | ((columns: Column<any>[]) => Column<any>[])): Column<Spec>[] | null;

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

@@ -0,0 +1,151 @@
+import { useMemo, useRef } from "react";
+import { computeField } from "@1771technologies/lytenyte-core/internal";
+import { equal, itemsWithIdToMap, measureText, } from "@1771technologies/lytenyte-shared";
+import { pivotPaths } from "./auxiliary-functions/pivot-paths.js";
+import { applyReferenceColumn } from "./auxiliary-functions/apply-reference-column.js";
+export function usePivotColumns(pivotMode, pivotControlled, model, leafs, filtered, processor) {
+    const measures = model?.measures;
+    const columns = model?.columns;
+    const prevMeasuresRef = useRef(measures);
+    const prevColumnsRef = useRef(columns);
+    const pivotControlledImmediateRef = useRef(pivotControlled.state);
+    pivotControlledImmediateRef.current = pivotControlled.state;
+    const pivotColumns = useMemo(() => {
+        if (!pivotMode)
+            return null;
+        // At this point we should check if we need to replace the pivot state
+        const prevMeasures = prevMeasuresRef.current;
+        const prevColumns = prevColumnsRef.current;
+        // If the measures or columns have changed, then the pivot state should be reset.
+        if (!equal(prevMeasures, measures) || !equal(prevColumns, columns)) {
+            pivotControlled.setState((prev) => ({
+                ...prev,
+                columnState: { ordering: [], pinning: {}, resizing: {} },
+                columnGroupState: {},
+            }));
+            pivotControlledImmediateRef.current = {
+                ...pivotControlledImmediateRef.current,
+                columnState: { ordering: [], pinning: {}, resizing: {} },
+                columnGroupState: {},
+            };
+            prevColumnsRef.current = columns;
+            prevMeasuresRef.current = measures;
+        }
+        if (!measures?.length && !columns?.length)
+            return [];
+        // There are only measures, hence each measure should become a column.
+        if (!columns?.length) {
+            return measures.map((x) => {
+                const column = applyReferenceColumn({
+                    id: x.dim.id,
+                    field: x.dim.id,
+                    name: x.dim.name,
+                }, x.dim);
+                return column;
+            });
+        }
+        const paths = pivotPaths(filtered, leafs, columns, measures, model?.colLabelFilter);
+        const lookup = Object.fromEntries((measures ?? []).map((x) => [x.dim.id, x]));
+        const cols = paths.map((path) => {
+            const partsRaw = path.split("-->");
+            const parts = partsRaw.map((x) => (x === "ln__blank__" ? "(blank)" : x));
+            if (parts.length === 1) {
+                return { id: path };
+            }
+            const measureId = parts.at(-1);
+            const measureRef = lookup[measureId]?.dim;
+            // Pop the last part as this is the aggregation value
+            parts.pop();
+            let name = measureId === "ln__noop" || measures?.length === 1 ? parts.at(-1) : measureId;
+            if (name === "ln__grand_total")
+                name = "Grand Total";
+            if (parts[0] === "ln__grand_total" && measures && measures.length > 1)
+                name = "Grand Total " + measureId;
+            if (name === "ln__total")
+                name = "Total";
+            const group = (parts.length === 1 && measures?.length === 1
+                ? undefined
+                : !measures?.length || measures.length === 1
+                    ? parts.slice(0, -1)
+                    : parts)?.map((x) => (x === "ln__total" ? "Total" : x));
+            partsRaw.pop();
+            const label = measures.length > 1 ? (measureRef?.name ?? name) : name;
+            const minWidth = measureText(label);
+            const column = applyReferenceColumn({
+                id: path,
+                name: label,
+                widthMin: minWidth?.width,
+                groupPath: group?.map((x) => {
+                    if (x === "ln__grand_total")
+                        return "Grand Total";
+                    if (x === "ln__total")
+                        return "Total";
+                    return x;
+                }),
+                groupVisibility: path.includes("ln__total") || path.includes("ln__grand_total") ? "always" : "open",
+                field: ({ row }) => {
+                    // If the value is a group then we can simply grab the aggregated value.
+                    if (row.kind === "branch" || row.kind === "aggregated")
+                        return row.data[path];
+                    // Pivots do not have leafs displayed. So here we do something interesting. We return true if the
+                    // row should be kept for this pivot, otherwise false. This is effectively a leaf row filter for pivots.
+                    // We can then aggregate these.
+                    for (let i = 0; i < columns.length; i++) {
+                        const c = columns[i];
+                        const field = c.field ?? c.id;
+                        const value = field ? computeField(field, row) : false;
+                        const match = partsRaw[i];
+                        // This is a total columns. Totals will always be one shorter than than the path
+                        if (i >= partsRaw.length)
+                            return true;
+                        const isMatch = match.startsWith("ln") ||
+                            String(value) === match ||
+                            (value == null && match === "ln__blank__");
+                        if (!isMatch)
+                            return false;
+                    }
+                    return true;
+                },
+            }, measureRef);
+            return column;
+        });
+        return cols;
+    }, [pivotMode, measures, columns, filtered, leafs, model?.colLabelFilter, pivotControlled]);
+    const pivotColumnsWithState = useMemo(() => {
+        if (!pivotColumns)
+            return null;
+        void pivotControlled.pivotColumnState;
+        const state = pivotControlledImmediateRef.current.columnState;
+        const byId = itemsWithIdToMap(pivotColumns);
+        const ordering = state.ordering.filter((x) => byId.has(x));
+        const withBlanks = pivotColumns.map((x) => (ordering.includes(x.id) ? null : x));
+        let orderPos = 0;
+        for (let i = 0; i < withBlanks.length; i++) {
+            if (withBlanks[i])
+                continue;
+            const id = state.ordering[orderPos];
+            const column = byId.get(id);
+            withBlanks[i] = column;
+            orderPos++;
+        }
+        Object.entries(state.resizing).forEach(([id, value]) => {
+            const column = byId.get(id);
+            if (!column)
+                return;
+            Object.assign(column, { width: value });
+        });
+        Object.entries(state.pinning).forEach(([id, value]) => {
+            const column = byId.get(id);
+            if (!column)
+                return;
+            Object.assign(column, { pin: value });
+        });
+        return withBlanks;
+    }, [pivotColumns, pivotControlled.pivotColumnState]);
+    const processedColumns = useMemo(() => {
+        if (!processor || !pivotColumnsWithState)
+            return pivotColumnsWithState;
+        return processor(pivotColumnsWithState);
+    }, [pivotColumnsWithState, processor]);
+    return processedColumns;
+}