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

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-are-valid.js

@@ -0,0 +1,14 @@
+const invalidItemKeyType = "Invalid set action items, 'relIndex' must be a positive integer";
+export function checkSetActionItemKeysAreValid(p) {
+    if (!p.items?.length)
+        return true;
+    const items = p.items;
+    for (let i = items.length - 1; i >= 0; i--) {
+        const x = items[i];
+        if (typeof x.relIndex !== "number" || x.relIndex < 0 || Math.floor(x.relIndex) !== x.relIndex) {
+            console.error(invalidItemKeyType, p);
+            return false;
+        }
+    }
+    return true;
+}

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-fit.d.ts

@@ -0,0 +1,2 @@
+import type { SetDataAction, TreeParent, TreeRoot } from "./+types.async-tree.js";
+export declare function checkSetActionItemKeysFit<K, D>(p: SetDataAction<K, D>, pathNode: TreeParent<K, D> | TreeRoot<K, D>): boolean;

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-fit.js

@@ -0,0 +1,18 @@
+const invalidItemKeySize = "Invalid set action items, 'relIndex' must be less than parent size";
+export function checkSetActionItemKeysFit(p, pathNode) {
+    // If we are not adding any items, then the items definitely fit - since 0 fits in 0.
+    if (!p.items?.length)
+        return true;
+    // Grab the node size. The action may be updating the size, so we check for that first, otherwise
+    // we check if the current size.
+    const size = p.size ?? pathNode.size;
+    // We check the relative item indices. They should be within the size.
+    for (let i = p.items.length - 1; i >= 0; i--) {
+        const x = p.items[i];
+        if (x.relIndex >= size) {
+            console.error(invalidItemKeySize, p, pathNode);
+            return false;
+        }
+    }
+    return true;
+}

package/dist/row-data-source-server/async-tree/check-set-action-item-kinds.d.ts

@@ -0,0 +1,2 @@
+import type { SetDataAction } from "./+types.async-tree.js";
+export declare function checkSetActionItemKinds<K, D>(p: SetDataAction<K, D>): boolean;

package/dist/row-data-source-server/async-tree/check-set-action-item-kinds.js

@@ -0,0 +1,14 @@
+const invalidItemKind = "Invalid set action items, 'kind' must be 'leaf' or 'parent'";
+export function checkSetActionItemKinds(p) {
+    if (!p.items?.length)
+        return true;
+    const items = p.items;
+    for (let i = items.length - 1; i >= 0; i--) {
+        const x = items[i];
+        if (x.kind !== "leaf" && x.kind !== "parent") {
+            console.error(invalidItemKind, p);
+            return false;
+        }
+    }
+    return true;
+}

package/dist/row-data-source-server/async-tree/get-parent-node-by-path.d.ts

@@ -0,0 +1,2 @@
+import type { TreeParent, TreeRoot } from "./+types.async-tree.js";
+export declare function getParentNodeByPath<K, D>(tree: TreeRoot<K, D>, path: (string | null)[]): TreeRoot<K, D> | TreeParent<K, D> | null;

package/dist/row-data-source-server/async-tree/get-parent-node-by-path.js

@@ -0,0 +1,18 @@
+const invalidPathRoute = "Invalid path specified. Paths must be built up incrementally.";
+const invalidPathChild = "Invalid path specified. Leaf nodes can have children.";
+export function getParentNodeByPath(tree, path) {
+    let target = tree;
+    for (let i = 0; i < path.length; i++) {
+        const next = target.byPath.get(path[i]);
+        if (!next) {
+            console.error(invalidPathRoute, path.slice(0, i));
+            return null;
+        }
+        if (next.kind === "leaf") {
+            console.error(invalidPathChild, path.slice(0, i));
+            return null;
+        }
+        target = next;
+    }
+    return target;
+}

package/dist/row-data-source-server/async-tree/is-set-action-a-no-op-on-node.d.ts

@@ -0,0 +1,2 @@
+import type { SetDataAction, TreeParent, TreeRoot } from "./+types.async-tree.js";
+export declare function isSetActionANoOpOnNode<K, D>(p: SetDataAction<K, D>, pathNode: TreeParent<K, D> | TreeRoot<K, D>): boolean;

package/dist/row-data-source-server/async-tree/is-set-action-a-no-op-on-node.js

@@ -0,0 +1,3 @@
+export function isSetActionANoOpOnNode(p, pathNode) {
+    return p.size === pathNode.size && !p.items?.length;
+}

package/dist/row-data-source-server/async-tree/make-async-tree.d.ts

@@ -0,0 +1,2 @@
+import type { TreeRootAndApi } from "./+types.async-tree";
+export declare function makeAsyncTree<K = any, D = any>(): TreeRootAndApi<K, D>;

package/dist/row-data-source-server/async-tree/make-async-tree.js

@@ -0,0 +1,19 @@
+import { applyDeleteActionToTree } from "./apply-delete-action-to-tree";
+import { applySetActionToTree } from "./apply-set-action-to-tree";
+import { getParentNodeByPath } from "./get-parent-node-by-path";
+export function makeAsyncTree() {
+    const tree = {
+        kind: "root",
+        byIndex: new Map(),
+        byPath: new Map(),
+        size: 0,
+        asOf: Date.now(),
+    };
+    const api = {
+        set: (p) => applySetActionToTree(p, tree),
+        delete: (p) => applyDeleteActionToTree(p, tree),
+        get: (p) => getParentNodeByPath(tree, p.path),
+    };
+    Object.assign(tree, api);
+    return tree;
+}

package/dist/row-data-source-server/async-tree/maybe-apply-parent-remove-self.d.ts

@@ -0,0 +1,2 @@
+import type { TreeParent, TreeRoot } from "./+types.async-tree.js";
+export declare function maybeApplyParentRemoveSelf<K, D>(pathNode: TreeParent<K, D> | TreeRoot<K, D>): boolean;

package/dist/row-data-source-server/async-tree/maybe-apply-parent-remove-self.js

@@ -0,0 +1,8 @@
+export function maybeApplyParentRemoveSelf(pathNode) {
+    if (!pathNode.size && pathNode.kind === "parent") {
+        pathNode.parent.byPath.delete(pathNode.path);
+        pathNode.parent.byIndex.delete(pathNode.relIndex);
+        return true;
+    }
+    return false;
+}

package/dist/row-data-source-server/async-tree/maybe-apply-resize.d.ts

@@ -0,0 +1,2 @@
+import type { TreeParent, TreeRoot } from "./+types.async-tree.js";
+export declare function maybeApplyResize<K, D>(pathNode: TreeParent<K, D> | TreeRoot<K, D>, size: number | undefined, asOf: number): boolean;

package/dist/row-data-source-server/async-tree/maybe-apply-resize.js

@@ -0,0 +1,17 @@
+export function maybeApplyResize(pathNode, size, asOf) {
+    if (size == null)
+        return false;
+    if (size === pathNode.size)
+        return false;
+    if (pathNode.asOf > asOf)
+        return false;
+    pathNode.size = size;
+    // Remove those nodes that are no long within the allowed size
+    for (const [number, node] of pathNode.byIndex) {
+        if (number >= size) {
+            pathNode.byIndex.delete(number);
+            pathNode.byPath.delete(node.path);
+        }
+    }
+    return true;
+}

package/dist/row-data-source-server/async-tree/maybe-apply-set-action-items.d.ts

@@ -0,0 +1,2 @@
+import type { SetDataAction, TreeParent, TreeRoot } from "./+types.async-tree.js";
+export declare function maybeApplySetActionItems<K, D>(p: SetDataAction<K, D>, pathNode: TreeParent<K, D> | TreeRoot<K, D>): boolean;

package/dist/row-data-source-server/async-tree/maybe-apply-set-action-items.js

@@ -0,0 +1,51 @@
+import { ROOT_LEAF_PREFIX } from "./+constants.async-tree.js";
+export function maybeApplySetActionItems(p, pathNode) {
+    if (!p.items?.length) {
+        return false;
+    }
+    const asOf = p.asOf ?? Date.now();
+    for (let i = 0; i < p.items.length; i++) {
+        const item = p.items[i];
+        const path = item.kind === "leaf" ? `${p.path.at(-1) ?? ROOT_LEAF_PREFIX}#${item.relIndex}` : item.path;
+        const existingIndex = pathNode.byIndex.get(item.relIndex);
+        if (existingIndex) {
+            pathNode.byPath.delete(existingIndex.path);
+            pathNode.byIndex.delete(item.relIndex);
+        }
+        const existing = pathNode.byPath.get(path);
+        if (existing) {
+            pathNode.byPath.delete(existing.path);
+            pathNode.byIndex.delete(existing.relIndex);
+        }
+        // We always replace when making a leaf
+        if (item.kind === "leaf") {
+            const node = { ...item, parent: pathNode, path: path, asOf };
+            const currentI = pathNode.byIndex.get(item.relIndex);
+            const currentP = pathNode.byPath.get(path);
+            if (!currentI || currentI.asOf < asOf)
+                pathNode.byIndex.set(item.relIndex, node);
+            if (!currentP || currentP.asOf < asOf)
+                pathNode.byPath.set(path, node);
+        }
+        else {
+            const node = {
+                byIndex: existing?.kind === "parent" ? existing.byIndex : new Map(),
+                byPath: existing?.kind === "parent" ? existing.byPath : new Map(),
+                data: item.data,
+                kind: "parent",
+                relIndex: item.relIndex,
+                parent: pathNode,
+                path,
+                size: item.size,
+                asOf,
+            };
+            const currentI = pathNode.byIndex.get(item.relIndex);
+            const currentP = pathNode.byPath.get(path);
+            if (!currentI || currentI.asOf < asOf)
+                pathNode.byIndex.set(item.relIndex, node);
+            if (!currentP || currentP.asOf < asOf)
+                pathNode.byPath.set(path, node);
+        }
+    }
+    return true;
+}

package/dist/row-data-source-server/range-tree/range-tree.d.ts

@@ -0,0 +1,66 @@
+import type { TreeParent, TreeRoot } from "../async-tree/+types.async-tree";
+/**
+ * Represents a flattened range with start/end row indices and an associated path.
+ */
+export type FlattenedRange = {
+    /** Starting row index (inclusive) */
+    rowStart: number;
+    /** Ending row index (exclusive) */
+    rowEnd: number;
+    /** Path identifier for this range */
+    parent: TreeParent<any, any> | TreeRoot<any, any>;
+};
+/**
+ * Represents a node in a range tree, containing a range and its nested child ranges.
+ */
+export interface RangeNode {
+    /** The range associated with this node */
+    range: FlattenedRange;
+    /** Child nodes representing nested ranges within this range */
+    children: RangeNode[];
+}
+/**
+ * A tree structure for efficient nested range operations.
+ *
+ * Maintains a hierarchical representation of ranges where parent ranges contain their
+ * child ranges. Provides methods for querying ranges that contain specific row indices.
+ *
+ * @remarks
+ * The tree is constructed by:
+ * 1. Sorting ranges by start index
+ * 2. Using the first range as root
+ * 3. Inserting subsequent ranges into their appropriate parent nodes
+ *
+ * @example
+ * ```typescript
+ * const ranges = [
+ *   { rowStart: 0, rowEnd: 100, path: 'root' },
+ *   { rowStart: 20, rowEnd: 50, path: 'child1' },
+ *   { rowStart: 30, rowEnd: 40, path: 'grandchild' }
+ * ];
+ *
+ * const tree = new RangeTree(ranges);
+ * const rangesAtRow25 = tree.findRangesForRowIndex(25);
+ * // Returns [root, child1]
+ * ```
+ */
+export declare class RangeTree {
+    /** Root node of the range tree */
+    root: RangeNode;
+    /**
+     * Creates a new range tree from an array of flattened ranges.
+     *
+     * @param ranges - Array of ranges to organize into a tree structure
+     */
+    constructor(ranges: FlattenedRange[]);
+    /**
+     * Finds all ranges that contain the specified row index.
+     *
+     * Traverses the tree from root to leaves, collecting all ranges that contain
+     * the target index. Returns ranges in order from outermost to innermost.
+     *
+     * @param index - Row index to search for
+     * @returns Array of ranges containing the index, ordered from outer to inner
+     */
+    findRangesForRowIndex(index: number): FlattenedRange[];
+}

package/dist/row-data-source-server/range-tree/range-tree.js

@@ -0,0 +1,102 @@
+/**
+ * A tree structure for efficient nested range operations.
+ *
+ * Maintains a hierarchical representation of ranges where parent ranges contain their
+ * child ranges. Provides methods for querying ranges that contain specific row indices.
+ *
+ * @remarks
+ * The tree is constructed by:
+ * 1. Sorting ranges by start index
+ * 2. Using the first range as root
+ * 3. Inserting subsequent ranges into their appropriate parent nodes
+ *
+ * @example
+ * ```typescript
+ * const ranges = [
+ *   { rowStart: 0, rowEnd: 100, path: 'root' },
+ *   { rowStart: 20, rowEnd: 50, path: 'child1' },
+ *   { rowStart: 30, rowEnd: 40, path: 'grandchild' }
+ * ];
+ *
+ * const tree = new RangeTree(ranges);
+ * const rangesAtRow25 = tree.findRangesForRowIndex(25);
+ * // Returns [root, child1]
+ * ```
+ */
+export class RangeTree {
+    /** Root node of the range tree */
+    root;
+    /**
+     * Creates a new range tree from an array of flattened ranges.
+     *
+     * @param ranges - Array of ranges to organize into a tree structure
+     */
+    constructor(ranges) {
+        const sortedRanges = ranges.toSorted((left, right) => left.rowStart - right.rowStart);
+        const root = { range: sortedRanges[0], children: [] };
+        for (let i = 1; i < sortedRanges.length; i++) {
+            insert(root, sortedRanges[i]);
+        }
+        this.root = root;
+    }
+    /**
+     * Finds all ranges that contain the specified row index.
+     *
+     * Traverses the tree from root to leaves, collecting all ranges that contain
+     * the target index. Returns ranges in order from outermost to innermost.
+     *
+     * @param index - Row index to search for
+     * @returns Array of ranges containing the index, ordered from outer to inner
+     */
+    findRangesForRowIndex(index) {
+        const ranges = [];
+        let currentNode = this.root;
+        while (currentNode) {
+            if (index >= currentNode.range.rowStart && index < currentNode.range.rowEnd) {
+                ranges.push(currentNode.range);
+                currentNode = currentNode.children.find((child) => index >= child.range.rowStart && index < child.range.rowEnd);
+            }
+            else {
+                break;
+            }
+        }
+        return ranges;
+    }
+}
+/**
+ * Inserts a range into the appropriate position in the range tree.
+ *
+ * Recursively finds the most deeply nested existing range that contains the new range,
+ * then adds the new range as a child of that node.
+ *
+ * @param node - Current node to check for insertion
+ * @param range - Range to insert into the tree
+ */
+function insert(node, range) {
+    // Check each child to see if it contains this range
+    for (const child of node.children) {
+        if (containsRange(child.range, range)) {
+            insert(child, range);
+            return;
+        }
+    }
+    // If we get here, this node is the parent
+    node.children.push({
+        range,
+        children: [],
+    });
+}
+/**
+ * Determines if one range fully contains another range.
+ *
+ * A range contains another range if its start index is less than or equal to
+ * the inner range's start AND its end index is greater than or equal to
+ * the inner range's end.
+ *
+ * @param outer - The potentially containing range
+ * @param inner - The potentially contained range
+ * @returns true if outer fully contains inner, false otherwise
+ */
+function containsRange(outer, inner) {
+    return outer.rowStart <= inner.rowStart && outer.rowEnd >= inner.rowEnd;
+}

package/dist/row-data-source-server/use-server-data-source.d.ts

@@ -0,0 +1,3 @@
+import type { RowDataSourceServer, RowDataSourceServerParams } from "../+types";
+export declare function makeServerDataSource<T>({ dataFetcher, dataColumnPivotFetcher, dataInFilterItemFetcher, cellUpdateHandler, cellUpdateOptimistically, blockSize, }: RowDataSourceServerParams<T>): RowDataSourceServer<T>;
+export declare function useServerDataSource<T>(p: RowDataSourceServerParams<T>): RowDataSourceServer<T>;