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

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")
+                    return 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.js";
+export declare function createAggModel<T>(model: ColumnPivotModel<T>, columns: Column<T>[], separator: string): {
+    [k: string]: {
+        readonly fn: import("../../+types.js").AggModelFn<T>;
+    };
+};

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

@@ -0,0 +1,13 @@
+import {} from "../../+types.js";
+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.js";
+import { createPivotTree } from "./create-pivot-tree.js";
+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.js";
+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.js";
+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.js";
+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;

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

@@ -0,0 +1,22 @@
+import { LEAF } from "../+constants.js";
+export function traverse(root, fn, comparator) {
+    const entries = root instanceof Map ? root.entries() : root.children.entries();
+    const stack = [...entries];
+    if (comparator)
+        stack.sort((l, r) => comparator(l[1], r[1]));
+    while (stack.length) {
+        const [key, node] = stack.shift();
+        if (node.kind === LEAF) {
+            fn(node, key);
+        }
+        else {
+            const continueWith = fn(node, key) ?? true;
+            if (continueWith) {
+                const children = [...node.children];
+                if (comparator)
+                    children.sort((l, r) => comparator(l[1], r[1]));
+                stack.unshift(...children);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { GridAtom, RowDataSourceClientPaginated } from "../+types.js";
+import { type ClientRowDataSourcePaginatedParams } from "../+types.js";
+interface DataAtoms<T> {
+    readonly top: GridAtom<T[]>;
+    readonly center: GridAtom<T[]>;
+    readonly bottom: GridAtom<T[]>;
+}
+export declare function makeClientDataSourcePaginated<T>(p: ClientRowDataSourcePaginatedParams<T>): [RowDataSourceClientPaginated<T>, DataAtoms<T>];
+export declare function useClientRowDataSourcePaginated<T>(p: ClientRowDataSourcePaginatedParams<T>): RowDataSourceClientPaginated<T>;
+export {};