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

package/dist/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/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.js";
+export declare function isSetActionANoOpOnNode(p: SetDataAction, pathNode: TreeParent | TreeRoot): boolean;

package/dist/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/data-source-server/async-tree/make-async-tree.d.ts

@@ -0,0 +1,2 @@
+import type { TreeRootAndApi } from "./types";
+export declare function makeAsyncTree(): TreeRootAndApi;

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

@@ -0,0 +1,64 @@
+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(),
+        rowIdToNode: new Map(),
+        before: [],
+        after: [],
+    };
+    const api = {
+        set: (p) => applySetActionToTree(p, tree),
+        delete: (p) => applyDeleteActionToTree(p, tree),
+        get: (p) => getParentNodeByPath(tree, p.path),
+        addBefore: (leafs) => {
+            for (const l of leafs) {
+                if (tree.before.find((x) => x.row.id === l.row.id)) {
+                    console.error(`Attempting to add row with ${l.row.id} but it has already been added.`);
+                    return;
+                }
+                if (tree.rowIdToNode.has(l.row.id)) {
+                    console.error(`Attempt to add row with ${l.row.id} but this row already exists.`);
+                    return;
+                }
+                tree.before.push(l);
+                tree.rowIdToNode.set(l.row.id, l);
+            }
+        },
+        addAfter: (leafs) => {
+            for (const l of leafs) {
+                if (tree.after.find((x) => x.row.id === l.row.id)) {
+                    console.error(`Attempting to add row with ${l.row.id} but it has already been added.`);
+                    return;
+                }
+                if (tree.rowIdToNode.has(l.row.id)) {
+                    console.error(`Attempt to add row with ${l.row.id} but this row already exists.`);
+                    return;
+                }
+                tree.after.push(l);
+                tree.rowIdToNode.set(l.row.id, l);
+            }
+        },
+        deleteBefore: (leafs) => {
+            const found = new Set(leafs.map((l) => tree.before.find((x) => x.row.id === l)).filter((x) => !!x));
+            tree.before = tree.before.filter((x) => !found.has(x));
+            found.forEach((x) => {
+                tree.rowIdToNode.delete(x.row.id);
+            });
+        },
+        deleteAfter: (leafs) => {
+            const found = new Set(leafs.map((l) => tree.after.find((x) => x.row.id === l)).filter((x) => !!x));
+            tree.after = tree.after.filter((x) => !found.has(x));
+            found.forEach((x) => {
+                tree.rowIdToNode.delete(x.row.id);
+            });
+        },
+    };
+    Object.assign(tree, api);
+    return tree;
+}

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

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

package/dist/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/data-source-server/async-tree/maybe-apply-resize.d.ts

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

package/dist/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/data-source-server/async-tree/maybe-apply-set-action-items.d.ts

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

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

@@ -0,0 +1,54 @@
+import { ROOT_LEAF_PREFIX } from "./+constants.async-tree.js";
+export function maybeApplySetActionItems(p, pathNode, root) {
+    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);
+            root.rowIdToNode.set(node.row.id, node);
+        }
+        else {
+            const node = {
+                byIndex: existing?.kind === "parent" ? existing.byIndex : new Map(),
+                byPath: existing?.kind === "parent" ? existing.byPath : new Map(),
+                row: item.row,
+                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);
+            root.rowIdToNode.set(node.row.id, node);
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,70 @@
+import type { RowGroup, RowLeaf } from "@1771technologies/lytenyte-shared";
+/**
+ * The root of the async tree. This is the entry point of the tree.
+ */
+export type TreeRoot = {
+    readonly kind: "root";
+    readonly byPath: Map<string | null, LeafOrParent>;
+    readonly byIndex: Map<number, LeafOrParent>;
+    readonly size: number;
+    readonly asOf: number;
+    readonly rowIdToNode: Map<string, LeafOrParent>;
+    before: TreeLeaf[];
+    after: TreeLeaf[];
+};
+export type TreeParent = {
+    readonly kind: "parent";
+    readonly relIndex: number;
+    readonly row: RowGroup;
+    readonly asOf: number;
+    readonly byPath: Map<string | null, LeafOrParent>;
+    readonly byIndex: Map<number, LeafOrParent>;
+    readonly size: number;
+    readonly path: string | null;
+    readonly parent: TreeParent | TreeRoot;
+    readonly deleted?: boolean;
+};
+export type TreeLeaf = {
+    readonly kind: "leaf";
+    readonly relIndex: number;
+    readonly row: RowLeaf;
+    readonly asOf: number;
+    readonly parent: TreeParent | TreeRoot;
+    readonly path: string;
+    readonly deleted?: boolean;
+    readonly optimistic?: "start" | "end";
+};
+export type LeafOrParent = TreeLeaf | TreeParent;
+export type TreeRootAndApi = TreeRoot & {
+    readonly set: (payload: SetDataAction) => void;
+    readonly delete: (path: DeleteDataAction) => void;
+    readonly get: (payload: GetDataAction) => TreeRoot | TreeParent | null;
+    readonly addBefore: (leafs: TreeLeaf[]) => void;
+    readonly addAfter: (leafs: TreeLeaf[]) => void;
+    readonly deleteBefore: (ids: string[]) => void;
+    readonly deleteAfter: (ids: string[]) => void;
+};
+export interface SetDataAction {
+    readonly path: (string | null)[];
+    readonly asOf?: number;
+    readonly size?: number;
+    readonly items?: ({
+        kind: "parent";
+        path: string | null;
+        row: RowGroup;
+        relIndex: number;
+        size: number;
+    } | {
+        kind: "leaf";
+        row: RowLeaf;
+        relIndex: number;
+    })[];
+}
+export interface DeleteDataAction {
+    readonly path: (string | null)[];
+    readonly paths?: string[];
+    readonly relIndices?: number[];
+}
+export interface GetDataAction {
+    readonly path: (string | null)[];
+}

package/dist/data-source-server/async-tree/types.js

@@ -0,0 +1 @@
+export {};

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

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

@@ -0,0 +1,73 @@
+import { type RowNode } from "@1771technologies/lytenyte-shared";
+import type { LeafOrParent, TreeLeaf, TreeRootAndApi } from "./async-tree/types.js";
+import { RangeTree } from "./range-tree/range-tree.js";
+import type { DataRequest, DataResponse, DataResponsePinned } from "./types.js";
+export type DataFetcher = (req: DataRequest[], expansions: Record<string, boolean | undefined>) => Promise<(DataResponse | DataResponsePinned)[]>;
+export interface FlatView {
+    readonly tree: TreeRootAndApi;
+    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>;
+    readonly loading: Set<number>;
+    readonly loadingGroup: Set<number>;
+    readonly errored: Map<number, {
+        error: unknown;
+        request?: DataRequest;
+    }>;
+    readonly erroredGroup: Map<number, {
+        error: unknown;
+        request: DataRequest;
+    }>;
+    readonly maxDepth: number;
+    readonly seenRequests: Set<string>;
+}
+export interface ServerDataConstructorParams {
+    readonly blocksize: number;
+    readonly expansions: Record<string, boolean | undefined>;
+    readonly onResetLoadBegin: () => void;
+    readonly onResetLoadError: (error: unknown) => void;
+    readonly onResetLoadEnd: () => void;
+    readonly onFlatten: (r: FlatView) => void;
+    readonly onInvalidate: () => void;
+    readonly defaultExpansion: boolean | number;
+}
+export declare class ServerData {
+    #private;
+    tree: TreeRootAndApi;
+    flat: FlatView;
+    constructor({ blocksize, expansions, onResetLoadBegin, onResetLoadEnd, onResetLoadError, onFlatten, onInvalidate, defaultExpansion, }: ServerDataConstructorParams);
+    set dataFetcher(d: DataFetcher);
+    set expansions(d: Record<string, boolean | undefined>);
+    set defaultExpansion(d: boolean | number);
+    set rowViewBounds(viewBounds: [start: number, end: number]);
+    reset: () => Promise<void>;
+    requestForGroup(i: number): DataRequest | null;
+    handleRequests: (requests: DataRequest[], opts?: {
+        onError?: (e: unknown) => void;
+        onSuccess?: () => void;
+        skipState?: boolean;
+    }) => Promise<void>;
+    handleResponses: (data: (DataResponse | DataResponsePinned)[], beforeOnFlat?: () => void) => void;
+    requestForNextSlice(req: DataRequest): {
+        id: string;
+        path: (string | null)[];
+        start: number;
+        end: number;
+        rowStartIndex: number;
+        rowEndIndex: number;
+    } | null;
+    requestsForView(start?: number, end?: number): DataRequest[];
+    handleViewBoundsChange(): Promise<void>;
+    retry(): void;
+    addBefore(leafs: TreeLeaf[]): void;
+    addAfter(leafs: TreeLeaf[]): void;
+    deleteBefore(leafs: string[]): void;
+    deleteAfter(leafs: string[]): void;
+    updateRow(id: string, data: any, asOf?: number): void;
+    flatten: () => void;
+}