@1771technologies/lytenyte-pro 0.9.4 → 1.0.0-beta.1

package/dist/row-data-source-client/built-ins/built-ins.js

@@ -0,0 +1,44 @@
+import { avg } from "./avg.js";
+import { count } from "./count.js";
+import { first } from "./first.js";
+import { group } from "./group.js";
+import { last } from "./last.js";
+import { max } from "./max.js";
+import { min } from "./min.js";
+import { sum } from "./sum.js";
+/**
+ * Collection of built-in array utility functions for numerical and statistical operations.
+ * Each function handles null and undefined values gracefully.
+ * @example
+ * import { builtIns } from './builtIns';
+ *
+ * const data = [1, null, 3, 2];
+ * builtIns.sum(data);  // Returns 6
+ * builtIns.avg(data);  // Returns 2
+ */
+export const builtIns = {
+    /** Calculate sum of non-null numbers in array */
+    sum: sum,
+    /** Count non-null/undefined elements in array */
+    count: count,
+    /** Calculate average of non-null numbers in array */
+    avg: avg,
+    /** Get first non-null/undefined element in array */
+    first: first,
+    /** Get last non-null/undefined element in array */
+    last: last,
+    /** Find minimum value among non-null/undefined numbers in array */
+    min: min,
+    /** Find maximum value among non-null/undefined numbers in array */
+    max: max,
+    /** Return the aggregation group */
+    group: group,
+};
+/**
+ * Set containing valid built-in function names.
+ * Used for validating function names and checking available operations.
+ * @example
+ * const isValidFunction = validBuiltIns.has('sum');  // Returns true
+ * const isInvalidFunction = validBuiltIns.has('median');  // Returns false
+ */
+export const validBuiltIns = new Set(Object.keys(builtIns));

package/dist/row-data-source-client/built-ins/count.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Counts the number of non-null elements in an array.
+ * @param data - An array of any type
+ * @returns The count of elements that are neither null nor undefined
+ * @example
+ * count([1, null, 'a', undefined]) // Returns 2
+ * count([]) // Returns 0
+ * count([null, undefined]) // Returns 0
+ */
+export declare function count(d: unknown[]): number;

package/dist/row-data-source-client/built-ins/count.js

@@ -0,0 +1,16 @@
+/**
+ * Counts the number of non-null elements in an array.
+ * @param data - An array of any type
+ * @returns The count of elements that are neither null nor undefined
+ * @example
+ * count([1, null, 'a', undefined]) // Returns 2
+ * count([]) // Returns 0
+ * count([null, undefined]) // Returns 0
+ */
+export function count(d) {
+    let c = 0;
+    for (let i = d.length - 1; i >= 0; i--)
+        if (d[i] != null)
+            c++;
+    return c;
+}

package/dist/row-data-source-client/built-ins/first.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the first non-null element in an array.
+ * @param data - An array of any type
+ * @returns The first element that is neither null nor undefined, or undefined if no such element exists
+ * @example
+ * first([null, 1, 2]) // Returns 1
+ * first([]) // Returns undefined
+ * first([null, undefined]) // Returns undefined
+ */
+export declare function first(d: unknown[]): {} | undefined;

package/dist/row-data-source-client/built-ins/first.js

@@ -0,0 +1,12 @@
+/**
+ * Returns the first non-null element in an array.
+ * @param data - An array of any type
+ * @returns The first element that is neither null nor undefined, or undefined if no such element exists
+ * @example
+ * first([null, 1, 2]) // Returns 1
+ * first([]) // Returns undefined
+ * first([null, undefined]) // Returns undefined
+ */
+export function first(d) {
+    return d.find((c) => c != null);
+}

package/dist/row-data-source-client/built-ins/group.d.ts

@@ -0,0 +1 @@
+export declare function group(data: unknown[]): unknown[];

package/dist/row-data-source-client/built-ins/group.js

@@ -0,0 +1,3 @@
+export function group(data) {
+    return data;
+}

package/dist/row-data-source-client/built-ins/last.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the last non-null element in an array.
+ * @param data - An array of any type
+ * @returns The last element that is neither null nor undefined, or undefined if no such element exists
+ * @example
+ * last([1, 2, null]) // Returns 2
+ * last([]) // Returns undefined
+ * last([null, undefined]) // Returns undefined
+ */
+export declare function last(d: unknown[]): {} | undefined;

package/dist/row-data-source-client/built-ins/last.js

@@ -0,0 +1,12 @@
+/**
+ * Returns the last non-null element in an array.
+ * @param data - An array of any type
+ * @returns The last element that is neither null nor undefined, or undefined if no such element exists
+ * @example
+ * last([1, 2, null]) // Returns 2
+ * last([]) // Returns undefined
+ * last([null, undefined]) // Returns undefined
+ */
+export function last(d) {
+    return d.findLast((c) => c != null);
+}

package/dist/row-data-source-client/built-ins/max.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Finds the maximum value in an array of numbers that may include null or undefined values.
+ * Iterates through the array from right to left.
+ * @param data - An array of numbers that may include null or undefined values
+ * @returns The maximum number found in the array. Returns 0 for empty arrays or if no valid numbers are found.
+ * @example
+ * max([1, null, 3, undefined, 2]) // Returns 3
+ * max([]) // Returns 0
+ * max([null, undefined]) // Returns 0
+ */
+export declare function max(data: (number | null | undefined)[]): number;

package/dist/row-data-source-client/built-ins/max.js

@@ -0,0 +1,25 @@
+/**
+ * Finds the maximum value in an array of numbers that may include null or undefined values.
+ * Iterates through the array from right to left.
+ * @param data - An array of numbers that may include null or undefined values
+ * @returns The maximum number found in the array. Returns 0 for empty arrays or if no valid numbers are found.
+ * @example
+ * max([1, null, 3, undefined, 2]) // Returns 3
+ * max([]) // Returns 0
+ * max([null, undefined]) // Returns 0
+ */
+export function max(data) {
+    if (!data.length)
+        return 0;
+    let max = data[0];
+    for (let i = data.length - 1; i > 0; i--) {
+        const d = data[i];
+        if (d != null && max == null)
+            max = d;
+        else if (d == null)
+            continue;
+        else if (d > max)
+            max = data[i];
+    }
+    return max ?? 0;
+}

package/dist/row-data-source-client/built-ins/min.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Finds the minimum value in an array of numbers that may include null or undefined values.
+ * Iterates through the array from right to left.
+ * @param data - An array of numbers that may include null or undefined values
+ * @returns The minimum number found in the array. Returns 0 for empty arrays or if no valid numbers are found.
+ * @example
+ * min([1, null, 3, undefined, 2]) // Returns 1
+ * min([]) // Returns 0
+ * min([null, undefined]) // Returns 0
+ */
+export declare function min(data: (number | null | undefined)[]): number;

package/dist/row-data-source-client/built-ins/min.js

@@ -0,0 +1,25 @@
+/**
+ * Finds the minimum value in an array of numbers that may include null or undefined values.
+ * Iterates through the array from right to left.
+ * @param data - An array of numbers that may include null or undefined values
+ * @returns The minimum number found in the array. Returns 0 for empty arrays or if no valid numbers are found.
+ * @example
+ * min([1, null, 3, undefined, 2]) // Returns 1
+ * min([]) // Returns 0
+ * min([null, undefined]) // Returns 0
+ */
+export function min(data) {
+    if (!data.length)
+        return 0;
+    let min = data[0];
+    for (let i = data.length - 1; i > 0; i--) {
+        const d = data[i];
+        if (d != null && min == null)
+            min = d;
+        else if (d == null)
+            continue;
+        else if (d < min)
+            min = data[i];
+    }
+    return min ?? 0;
+}

package/dist/row-data-source-client/built-ins/sum.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calculates the sum of all non-null numbers in an array.
+ * @param data - An array of numbers that may include null values
+ * @returns The sum of all non-null numbers in the array. Returns 0 for empty arrays or arrays containing only null values.
+ * @example
+ * sum([1, 2, null, 3]) // Returns 6
+ * sum([]) // Returns 0
+ * sum([null, null]) // Returns 0
+ */
+export declare function sum(data: (number | null)[]): number;

package/dist/row-data-source-client/built-ins/sum.js

@@ -0,0 +1,21 @@
+/**
+ * Calculates the sum of all non-null numbers in an array.
+ * @param data - An array of numbers that may include null values
+ * @returns The sum of all non-null numbers in the array. Returns 0 for empty arrays or arrays containing only null values.
+ * @example
+ * sum([1, 2, null, 3]) // Returns 6
+ * sum([]) // Returns 0
+ * sum([null, null]) // Returns 0
+ */
+export function sum(data) {
+    if (!data.length)
+        return 0;
+    let total = 0;
+    for (let i = data.length - 1; i >= 0; i--) {
+        const d = data[i];
+        if (d == null)
+            continue;
+        total += d;
+    }
+    return total;
+}

package/dist/row-data-source-client/filter/+types.d.ts

@@ -0,0 +1,23 @@
+import type { FilterDateSetting, FilterNumberSettings, FilterStringSettings } from "@1771technologies/lytenyte-shared";
+import type { FilterCombinationOperator, FilterDate, FilterFunc, FilterIn, FilterNumber, FilterString } from "../../+types";
+export interface FilterDateWithSettings extends FilterDate {
+    readonly field: string;
+    readonly settings: FilterDateSetting;
+}
+export interface FilterStringWithSettings extends FilterString {
+    readonly field: string;
+    readonly settings: FilterStringSettings;
+}
+export interface FilterNumberWithSettings extends FilterNumber {
+    readonly field: string;
+    readonly settings: FilterNumberSettings;
+}
+export interface FilterInWithField extends FilterIn {
+    readonly field: string;
+}
+export interface FilterCombinationWithSettings {
+    readonly kind: "combination";
+    readonly operator: FilterCombinationOperator;
+    readonly filters: Array<FilterStringWithSettings | FilterNumberWithSettings | FilterDateWithSettings | FilterCombinationWithSettings>;
+}
+export type FilterWithSettings<T> = FilterDateWithSettings | FilterStringWithSettings | FilterNumberWithSettings | FilterCombinationWithSettings | FilterInWithField | FilterFunc<T>;

package/dist/row-data-source-client/filter/+types.js

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

package/dist/row-data-source-client/filter/compute-filtered-rows.d.ts

@@ -0,0 +1,2 @@
+import type { FilterIn, FilterModelItem, FilterQuickSearchSensitivity, Grid, RowLeaf } from "../../+types";
+export declare function computeFilteredRows<T>(rows: RowLeaf<T>[], grid: Grid<T> | null, filterModel: Record<string, FilterModelItem<T>>, filterInModel: Record<string, FilterIn>, quickSearch: string | null, sensitivity: FilterQuickSearchSensitivity, isPivot: boolean): RowLeaf<T>[];

package/dist/row-data-source-client/filter/compute-filtered-rows.js

@@ -0,0 +1,109 @@
+import { evaluateDateFilter, evaluateNumberFilter, evaluateStringFilter, getDateFilterSettings, getNumberFilterSettings, getStringFilterSettings, } from "@1771technologies/lytenyte-shared";
+import { itemsWithIdToMap } from "@1771technologies/lytenyte-js-utils";
+export function computeFilteredRows(rows, grid, filterModel, filterInModel, quickSearch, sensitivity, isPivot) {
+    if (!grid)
+        return rows;
+    const columns = isPivot ? grid.state.columnPivotColumns.get() : grid.state.columns.get();
+    const lookup = itemsWithIdToMap(columns);
+    const filterEntries = [...Object.entries(filterModel), ...Object.entries(filterInModel)].filter(([key]) => {
+        return lookup.has(key);
+    });
+    if (!(filterEntries.length || quickSearch) || !grid)
+        return rows;
+    const filters = filterEntries.map(([key, f]) => createFilter(key, f));
+    const filtered = [];
+    const base = grid.state.columnBase.get();
+    const nonIgnored = columns.filter((c) => !(c.quickSearchIgnore ?? base.quickSearchIgnore));
+    for (let r = 0; r < rows.length; r++) {
+        const row = rows[r];
+        if (!filters.every((filter) => evaluateFilter(row.data, grid, filter)))
+            continue;
+        if (quickSearch) {
+            const pass = nonIgnored.some((c) => {
+                const field = `${grid.api.columnField(c, { data: row.data, kind: "leaf" })}`;
+                if (sensitivity === "case-insensitive")
+                    field.toLowerCase().includes(quickSearch.toLowerCase());
+                return field.includes(quickSearch);
+            });
+            if (!pass)
+                continue;
+        }
+        filtered.push(row);
+    }
+    return filtered;
+}
+function createFilter(id, filter) {
+    if (filter.kind === "date") {
+        const settings = getDateFilterSettings(filter);
+        return {
+            ...filter,
+            field: id,
+            kind: "date",
+            settings,
+        };
+    }
+    else if (filter.kind === "number") {
+        const settings = getNumberFilterSettings(filter);
+        return {
+            ...filter,
+            field: id,
+            kind: "number",
+            settings,
+        };
+    }
+    else if (filter.kind === "string") {
+        const settings = getStringFilterSettings(filter);
+        return {
+            ...filter,
+            field: id,
+            kind: "string",
+            settings,
+        };
+    }
+    else if (filter.kind === "in") {
+        return {
+            ...filter,
+            field: id,
+        };
+    }
+    else if (filter.kind === "combination") {
+        return {
+            ...filter,
+            kind: "combination",
+            filters: filter.filters.map((f) => createFilter(id, f)),
+        };
+    }
+    else if (filter.kind === "func") {
+        return filter;
+    }
+    else {
+        throw new Error(`Invalid filter provided: ${JSON.stringify(filter)}`);
+    }
+}
+function evaluateFilter(row, grid, filter) {
+    if (filter.kind === "date") {
+        const fieldValue = grid.api.columnField(filter.field, { data: row, kind: "leaf" });
+        return evaluateDateFilter(filter, fieldValue, filter.settings);
+    }
+    else if (filter.kind === "string") {
+        const fieldValue = grid.api.columnField(filter.field, { data: row, kind: "leaf" });
+        return evaluateStringFilter(filter, fieldValue, filter.settings);
+    }
+    else if (filter.kind === "number") {
+        const fieldValue = grid.api.columnField(filter.field, { data: row, kind: "leaf" });
+        return evaluateNumberFilter(filter, fieldValue, filter.settings);
+    }
+    else if (filter.kind === "func") {
+        return filter.func({ data: row, grid });
+    }
+    else if (filter.kind === "in") {
+        const fieldValue = grid.api.columnField(filter.field, { data: row, kind: "leaf" });
+        return filter.operator === "in" ? filter.value.has(fieldValue) : !filter.value.has(fieldValue);
+    }
+    else {
+        if (filter.operator === "AND")
+            return filter.filters.every((f) => evaluateFilter(row, grid, f));
+        else
+            return filter.filters.some((f) => evaluateFilter(row, grid, f));
+    }
+}

package/dist/row-data-source-client/pivots/create-agg-model.d.ts

@@ -0,0 +1,6 @@
+import { type Column, type ColumnPivotModel } from "../../+types";
+export declare function createAggModel<T>(model: ColumnPivotModel<T>, columns: Column<T>[], separator: string): {
+    [k: string]: {
+        readonly fn: import("../../+types").AggModelFn<T>;
+    };
+};

package/dist/row-data-source-client/pivots/create-agg-model.js

@@ -0,0 +1,13 @@
+import {} from "../../+types";
+export function createAggModel(model, columns, separator) {
+    const aggFunToId = new Map(model.values.map((c) => [c.field, c.aggFn]));
+    const aggModel = columns
+        .map((c) => {
+        const aggId = c.id.split(separator).at(-1);
+        if (!aggFunToId.has(aggId))
+            return null;
+        return [c.id, { fn: aggFunToId.get(aggId) }];
+    })
+        .filter((c) => !!c);
+    return Object.fromEntries(aggModel);
+}

package/dist/row-data-source-client/pivots/create-pivot-columns-from-paths.d.ts

@@ -0,0 +1,2 @@
+import type { Column, ColumnPivotModel, Grid } from "../../+types.js";
+export declare function createColumnPivotsFromPaths<T>(grid: Grid<T>, columns: ColumnPivotModel<T>["columns"], lookup: Map<string, Column<T>>, paths: string[]): Column<T>[];

package/dist/row-data-source-client/pivots/create-pivot-columns-from-paths.js

@@ -0,0 +1,50 @@
+import { upperCaseFirstLetter } from "@1771technologies/lytenyte-js-utils";
+export function createColumnPivotsFromPaths(grid, columns, lookup, paths) {
+    const separator = grid.state.columnGroupJoinDelimiter.get();
+    const cols = paths.map((path) => {
+        const parts = path.split(separator);
+        const measureId = parts.at(-1);
+        const measureCol = lookup.get(measureId);
+        // Pop the last part as this is the aggregation value
+        parts.pop();
+        const pivots = parts.map((_, index) => {
+            const id = columns[index].field;
+            return lookup.get(id);
+        });
+        const entries = [...pivots.entries()];
+        const isTotals = parts.length < columns.length;
+        const label = isTotals ? "Total" : parts.at(-1);
+        const groupPath = isTotals ? [] : parts.map(upperCaseFirstLetter);
+        const { pin: _, ...measureProps } = measureCol ?? {};
+        const newDefinitions = {
+            ...measureProps,
+            id: path,
+            name: label,
+            groupPath,
+            groupVisibility: "always",
+            field: ({ grid, data }) => {
+                if (!measureCol)
+                    return null;
+                if (data.kind === "branch") {
+                    return data.data[path];
+                }
+                if (!path.startsWith("total")) {
+                    for (const [index, pivot] of entries) {
+                        const key = parts[index];
+                        if (key == null)
+                            break;
+                        const actual = grid.api.columnField(pivot, data);
+                        if (key !== actual)
+                            return null;
+                    }
+                    return grid.api.columnField(measureCol, data);
+                }
+                else {
+                    return grid.api.columnField(measureCol, data);
+                }
+            },
+        };
+        return newDefinitions;
+    });
+    return cols;
+}

package/dist/row-data-source-client/pivots/create-pivot-columns.d.ts

@@ -0,0 +1,2 @@
+import type { Column, ColumnPivotModel, Grid, RowLeaf } from "../../+types";
+export declare function createPivotColumns<T>(model: ColumnPivotModel<T>, lookup: Map<string, Column<T>>, grid: Grid<T>, leafRows: RowLeaf<T>[]): Column<T>[];

package/dist/row-data-source-client/pivots/create-pivot-columns.js

@@ -0,0 +1,22 @@
+import { createColumnPivotsFromPaths } from "./create-pivot-columns-from-paths";
+import { createPivotTree } from "./create-pivot-tree";
+export function createPivotColumns(model, lookup, grid, leafRows) {
+    const activeColumns = model.columns.filter((c) => lookup.has(c.field) && (c.active ?? true));
+    const activeValues = model.values.filter((c) => lookup.has(c.field) && (c.active ?? true));
+    if (activeColumns.length === 0 && activeValues.length === 0)
+        return [];
+    // This means we only have a values column defined. Hence we should just return this.
+    if (activeColumns.length === 0) {
+        const columns = activeValues.map((c) => {
+            const col = lookup.get(c.field);
+            return {
+                ...col,
+                field: c.field,
+            };
+        });
+        return columns;
+    }
+    const tree = createPivotTree(grid, activeValues, activeColumns, lookup, leafRows);
+    const columns = createColumnPivotsFromPaths(grid, activeColumns, lookup, tree);
+    return columns;
+}

package/dist/row-data-source-client/pivots/create-pivot-tree.d.ts

@@ -0,0 +1,2 @@
+import type { Column, ColumnPivotModel, Grid, RowLeaf } from "../../+types";
+export declare function createPivotTree<T>(grid: Grid<T>, values: ColumnPivotModel<T>["values"], columns: ColumnPivotModel<T>["columns"], lookup: Map<string, Column<T>>, leafRows: RowLeaf<T>[]): string[];

package/dist/row-data-source-client/pivots/create-pivot-tree.js

@@ -0,0 +1,23 @@
+export function createPivotTree(grid, values, columns, lookup, leafRows) {
+    const sx = grid;
+    const measureEntries = values.length ? values.map((c) => c.field) : ["__EMPTY_LNG__"];
+    if (!measureEntries.length || !columns.length) {
+        return [];
+    }
+    const pivotedColumns = columns.map((p) => lookup.get(p.field));
+    const separator = sx.state.columnGroupJoinDelimiter.get();
+    const paths = new Set();
+    for (let i = 0; i < leafRows.length; i++) {
+        const current = [];
+        const row = leafRows[i];
+        for (const column of pivotedColumns) {
+            const pivotKey = String(grid.api.columnField(column, row));
+            current.push(pivotKey);
+        }
+        for (const measure of measureEntries) {
+            paths.add([...current, measure].join(separator));
+        }
+    }
+    measureEntries.forEach((id) => paths.add(`total${separator}${id}`));
+    return [...paths];
+}

package/dist/row-data-source-client/tree/client-tree.d.ts

@@ -0,0 +1,18 @@
+import type { AggregationItem, GroupItem, Root, TreeNode } from "../+types.js";
+export interface ClientData<Data> {
+    readonly root: Root<Data>;
+    readonly rowData: Data[];
+    readonly idsLeaf: Set<string>;
+    readonly idsBranch: Set<string>;
+    readonly idsAll: Set<string>;
+    readonly idToNode: Map<string, TreeNode<Data>>;
+    readonly idToSourceIndex: Map<string, number>;
+}
+export interface MakeClientDataArgs<Data> {
+    readonly rowData: Data[];
+    readonly rowBranchModel: GroupItem<Data>[] | ((d: Data) => (string | null | undefined)[]);
+    readonly rowAggModel: AggregationItem<Data>[];
+    readonly rowIdLeaf?: (d: Data, i: number) => string;
+    readonly rowIdGroup?: (path: string[]) => string;
+}
+export declare function makeClientTree<Data>({ rowData, rowBranchModel, rowAggModel, rowIdLeaf, rowIdGroup, }: MakeClientDataArgs<Data>): ClientData<Data>;

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

@@ -0,0 +1,76 @@
+import { BRANCH, LEAF } from "../+constants.js";
+import { traverse } from "./traverse.js";
+import { aggregationEvaluator } from "./evaluator-aggregation.js";
+import { groupEvaluator } from "./evaluator-group.js";
+export function makeClientTree({ rowData, rowBranchModel, rowAggModel, rowIdLeaf, rowIdGroup, }) {
+    const root = new Map();
+    const idsLeaf = new Set();
+    const idsBranch = new Set();
+    const idsAll = new Set();
+    const idToNode = new Map();
+    const idToSourceIndex = new Map();
+    for (let i = 0; i < rowData.length; i++) {
+        const d = rowData[i];
+        const id = rowIdLeaf?.(d, i) ?? `${i}`;
+        const path = groupEvaluator(rowBranchModel, d);
+        idsLeaf.add(id);
+        idsAll.add(id);
+        let current = root;
+        const runningPath = [];
+        for (let i = 0; i < path.length; i++) {
+            const pathKey = path[i] ?? `<__null__>`;
+            runningPath.push(pathKey);
+            const lookup = i === 0 ? root : current.children;
+            // We need to create a branch node.
+            if (!lookup.has(pathKey)) {
+                const id = rowIdGroup?.(runningPath) ?? "+.+" + runningPath.join("/");
+                idsBranch.add(id);
+                idsAll.add(id);
+                const branch = {
+                    id,
+                    kind: BRANCH,
+                    depth: i,
+                    children: new Map(),
+                    data: {},
+                    parent: current === root ? null : current,
+                    key: pathKey,
+                    leafIds: new Set(),
+                    leafData: [],
+                };
+                lookup.set(pathKey, branch);
+                idToNode.set(id, branch);
+            }
+            const branch = lookup.get(pathKey);
+            branch.leafData.push(d);
+            branch.leafIds.add(id);
+            current = branch;
+        }
+        const leaf = {
+            kind: LEAF,
+            id,
+            depth: path.length,
+            data: d,
+            parent: current === root ? null : current,
+        };
+        idToNode.set(id, leaf);
+        idToSourceIndex.set(id, i);
+        if (rowBranchModel.length === 0)
+            current.set(id, leaf);
+        else
+            current.children.set(id, leaf);
+    }
+    traverse(root, (node) => {
+        if (node.kind === LEAF)
+            return;
+        node.data = aggregationEvaluator(rowAggModel, node.leafData);
+    });
+    return {
+        root,
+        rowData,
+        idsLeaf: idsLeaf,
+        idsBranch: idsBranch,
+        idsAll: idsAll,
+        idToNode,
+        idToSourceIndex,
+    };
+}

package/dist/row-data-source-client/tree/evaluator-aggregation.d.ts

@@ -0,0 +1,2 @@
+import type { AggregationItem } from "../+types";
+export declare function aggregationEvaluator<Data>(agg: AggregationItem<Data>[], data: Data[]): Record<string, unknown>;

package/dist/row-data-source-client/tree/evaluator-aggregation.js

@@ -0,0 +1,8 @@
+export function aggregationEvaluator(agg, data) {
+    const result = {};
+    for (let i = 0; i < agg.length; i++) {
+        const a = agg[i];
+        result[a.name] = a.fn(data);
+    }
+    return result;
+}

package/dist/row-data-source-client/tree/evaluator-group.d.ts

@@ -0,0 +1,2 @@
+import type { GroupItem } from "../+types";
+export declare function groupEvaluator<Data>(g: GroupItem<Data>[] | ((d: Data) => (string | null | undefined)[]), d: Data): (string | null | undefined)[];

package/dist/row-data-source-client/tree/evaluator-group.js

@@ -0,0 +1,9 @@
+export function groupEvaluator(g, d) {
+    if (typeof g === "function")
+        return g(d);
+    const v = [];
+    for (let i = 0; i < g.length; i++) {
+        v.push(g[i].fn(d));
+    }
+    return v;
+}

package/dist/row-data-source-client/tree/traverse.d.ts

@@ -0,0 +1,2 @@
+import type { BranchNode, Root, TreeNode } from "../+types";
+export declare function traverse<Data>(root: Root<Data> | BranchNode<Data>, fn: (node: TreeNode<Data>, lookupKey: string | null) => boolean | void, comparator?: (l: TreeNode<Data>, r: TreeNode<Data>) => number): void;