@1771technologies/lytenyte-pro 1.0.0-beta.34 → 1.0.0-beta.36

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

@@ -1,22 +1,21 @@
 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);
+  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 +1,8 @@
 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[];
+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 +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 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);
     }
-    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));
-        }
+    for (const measure of measureEntries) {
+      paths.add([...current, measure].join(separator));
     }
-    measureEntries.forEach((id) => paths.add(`total${separator}${id}`));
-    return [...paths];
+  }
+  measureEntries.forEach((id) => paths.add(`total${separator}${id}`));
+  return [...paths];
 }

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

@@ -1,18 +1,24 @@
 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>;
+  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;
+  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>;
+export declare function makeClientTree<Data>({
+  rowData,
+  rowBranchModel,
+  rowAggModel,
+  rowIdLeaf,
+  rowIdGroup,
+}: MakeClientDataArgs<Data>): ClientData<Data>;

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

@@ -2,75 +2,72 @@ 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);
+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);
-        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,
+        const branch = {
+          id,
+          kind: BRANCH,
+          depth: i,
+          children: new Map(),
+          data: {},
+          parent: current === root ? null : current,
+          key: pathKey,
+          leafIds: new Set(),
+          leafData: [],
         };
-        idToNode.set(id, leaf);
-        idToSourceIndex.set(id, i);
-        if (rowBranchModel.length === 0)
-            current.set(id, leaf);
-        else
-            current.children.set(id, leaf);
+        lookup.set(pathKey, branch);
+        idToNode.set(id, branch);
+      }
+      const branch = lookup.get(pathKey);
+      branch.leafData.push(d);
+      branch.leafIds.add(id);
+      current = branch;
     }
-    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,
+    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 +1,5 @@
 import type { AggregationItem } from "../+types.js";
-export declare function aggregationEvaluator<Data>(agg: AggregationItem<Data>[], data: Data[]): Record<string, unknown>;
+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 +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;
+  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 +1,5 @@
 import type { GroupItem } from "../+types.js";
-export declare function groupEvaluator<Data>(g: GroupItem<Data>[] | ((d: Data) => (string | null | undefined)[]), d: Data): (string | null | undefined)[];
+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 +1,8 @@
 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;
+  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 +1,6 @@
 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;
+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 +1,19 @@
 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);
-            }
-        }
+  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 +1,14 @@
 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[]>;
+  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 declare function makeClientDataSourcePaginated<T>(
+  p: ClientRowDataSourcePaginatedParams<T>,
+): [RowDataSourceClientPaginated<T>, DataAtoms<T>];
+export declare function useClientRowDataSourcePaginated<T>(
+  p: ClientRowDataSourcePaginatedParams<T>,
+): RowDataSourceClientPaginated<T>;
 export {};