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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,19 +0,0 @@
-import { applyDeleteActionToTree } from "./apply-delete-action-to-tree.js";
-import { applySetActionToTree } from "./apply-set-action-to-tree.js";
-import { getParentNodeByPath } from "./get-parent-node-by-path.js";
-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

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

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

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

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

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

@@ -1,52 +0,0 @@
-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 existingByPath = pathNode.byPath.get(path);
-        if (existingByPath) {
-            pathNode.byPath.delete(existingByPath.path);
-            pathNode.byIndex.delete(existingByPath.relIndex);
-        }
-        const existing = existingByPath ?? existingIndex;
-        // 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

@@ -1,66 +0,0 @@
-import type { TreeParent, TreeRoot } from "../async-tree/+types.async-tree.js";
-/**
- * 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

@@ -1,102 +0,0 @@
-/**
- * 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/server-data.d.ts

@@ -1,48 +0,0 @@
-import type { DataRequest, DataResponse, DataResponsePinned, RowGroup, RowLeaf, RowNode } from "../+types.js";
-import type { LeafOrParent, TreeRootAndApi } from "./async-tree/+types.async-tree.js";
-import { RangeTree } from "./range-tree/range-tree.js";
-type DataFetcher = (req: DataRequest[], expansions: Record<string, boolean | undefined>, pivotExpansions: Record<string, boolean | undefined>) => Promise<(DataResponse | DataResponsePinned)[]>;
-export interface FlatView {
-    readonly tree: TreeRootAndApi<RowGroup, RowLeaf>;
-    readonly top: number;
-    readonly center: number;
-    readonly bottom: number;
-    readonly rangeTree: RangeTree;
-    readonly rowIndexToRow: Map<number, RowNode<any>>;
-    readonly rowIdToRow: Map<string, RowNode<any>>;
-    readonly rowIdToRowIndex: Map<string, number>;
-    readonly rowIdToTreeNode: Map<string, LeafOrParent<RowGroup, RowLeaf>>;
-    readonly loading: Set<number>;
-    readonly errored: Map<number, unknown>;
-}
-export interface ServerDataConstructorParams {
-    readonly blocksize: number;
-    readonly pivotMode: boolean;
-    readonly expansions: Record<string, boolean | undefined>;
-    readonly pivotExpansions: Record<string, boolean | undefined>;
-    readonly onResetLoadBegin: () => void;
-    readonly onResetLoadError: (error: unknown) => void;
-    readonly onResetLoadEnd: () => void;
-    readonly onFlatten: (r: FlatView) => void;
-    readonly defaultExpansion: boolean | number;
-}
-export declare class ServerData {
-    #private;
-    constructor({ blocksize, pivotMode, pivotExpansions, expansions, onResetLoadBegin, onResetLoadEnd, onResetLoadError, onFlatten, defaultExpansion, }: ServerDataConstructorParams);
-    set dataFetcher(d: DataFetcher);
-    set pivotMode(b: boolean);
-    set expansions(d: Record<string, boolean | undefined>);
-    set pivotExpansions(d: Record<string, boolean | undefined>);
-    set defaultExpansion(d: boolean | number);
-    set rowViewBounds(viewBounds: [start: number, end: number]);
-    reset: () => Promise<void>;
-    handleRequests: (requests: DataRequest[], opts?: {
-        onError?: (e: unknown) => void;
-        onSuccess?: () => void;
-        skipState?: boolean;
-    }) => Promise<void>;
-    handleResponses: (data: (DataResponse | DataResponsePinned)[], beforeOnFlat?: () => void) => void;
-    handleViewBoundsChange(): Promise<void>;
-    updateRow(id: string, data: any): void;
-}
-export {};