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

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

@@ -1,109 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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 {};