@1771technologies/lytenyte-pro 1.0.9 → 1.0.11

package/dist/+types.d.ts

@@ -5679,7 +5679,7 @@ export interface DataRequestModel<T> {
     /**
      * Group model defining how rows are grouped.
      */
-    readonly group: RowGroupModelItem<T>[];
+    readonly groups: RowGroupModelItem<T>[];
     /**
      * Expansion state of row groups by group key.
      */

package/dist/license.d.ts

@@ -1,2 +1,3 @@
 export function activateLicense(license: any): boolean;
 export let hasAValidLicense: boolean;
+export let licenseState: null;

package/dist/license.js

@@ -1,5 +1,5 @@
 const hashSalt = "faec0f3c45281b1fe12d87e64a6c3271";
-const issueDate = new Date("2025-09-01");
+const issueDate = new Date("2025-09-11");
 function getHostname() {
     const win = globalThis?.document?.defaultView || (typeof window !== "undefined" ? window : null);
     const loc = win?.location;
@@ -15,6 +15,7 @@ function isLocalhost() {
     return hostname.match(/^(?:127\.0\.0\.1|localhost)$/) !== null;
 }
 export let hasAValidLicense = isWebsiteUrl() || isLocalhost();
+export let licenseState = null;
 export function activateLicense(license) {
     const parts = license.split("|");
     const details = parts[0];
@@ -23,16 +24,14 @@ export function activateLicense(license) {
     if (detailHash !== hash) {
         console.error(`
 ********************************************************************************
-  INVALID LICENSE KEY SUPPLIED
+  LyteNyte Grid PRO
 
-  The license key you provided is not a valid LyteNyte Grid license key. If you
-  purchased a valid license from 1771 Technologies, please reach out to
-  our dedicated support email support@1771technologies.com.
+  Invalid license key. Please verify the key and try again.
 
-  If you are interested in purchasing a valid license, please
-  visit https://1771technolgies.com
+  Visit https://1771technolgies.com for more information.
 ********************************************************************************
 `);
+        licenseState = "invalid";
         return false;
     }
     const detailParts = details.split(" ");
@@ -40,16 +39,14 @@ export function activateLicense(license) {
     if (issueDate > endDate) {
         console.error(`
 ********************************************************************************
-    LICENSE EXPIRED
+  LyteNyte Grid PRO
 
-    The license provided is a valid LyteNyte license, however it is not valid for the
-    current version of LyteNyte Grid being used. Please renew your license or use
-    the fallback version valid under your license.
+  License key expired. Your license covers earlier versions only.
 
-    To purchase a new license or learn more about which versions your license is valid
-    for please visit https://1771technologies.com.
+  Visit https://1771technolgies.com for more information.
 ********************************************************************************
 `);
+        licenseState = "expired";
         return false;
     }
     hasAValidLicense = true;

package/dist/root/root.js

@@ -5,7 +5,7 @@ import { RootProvider } from "../context.js";
 import { DialogDriver } from "./dialog-driver.js";
 import { PopoverDriver } from "./popover-driver.js";
 import { CellSelectionDriver } from "../cell-selection/cell-selection-driver.js";
-import { hasAValidLicense } from "../license.js";
+import { hasAValidLicense, licenseState } from "../license.js";
 export function Root({ grid, children, ...events }) {
     useEffect(() => {
         if (hasAValidLicense)
@@ -23,7 +23,12 @@ export function Root({ grid, children, ...events }) {
         invalidLicenseWatermark.style.fontWeight = "bold";
         invalidLicenseWatermark.style.border = "1px solid black";
         invalidLicenseWatermark.style.padding = "16px";
-        invalidLicenseWatermark.innerHTML = `LyteNyte Grid PRO is being used for evaluation. 
+        if (licenseState === "expired")
+            invalidLicenseWatermark.innerHTML = `LyteNyte Grid: License key expired. Your license covers earlier versions only.`;
+        else if (licenseState === "invalid")
+            invalidLicenseWatermark.innerHTML = `LyteNyte Grid: Invalid license key. Please verify the key and try again.`;
+        else
+            invalidLicenseWatermark.innerHTML = `LyteNyte Grid PRO is being used for evaluation. 
       <a href="https://1771Technologies.com/pricing">Click here</a> to secure your license.`;
         document.body.appendChild(invalidLicenseWatermark);
         return () => invalidLicenseWatermark.remove();

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

@@ -12,11 +12,12 @@ export function maybeApplySetActionItems(p, pathNode) {
             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);
+        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 };

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

@@ -1,4 +1,4 @@
-import type { TreeParent, TreeRoot } from "../async-tree/+types.async-tree";
+import type { TreeParent, TreeRoot } from "../async-tree/+types.async-tree.js";
 /**
  * Represents a flattened range with start/end row indices and an associated path.
  */

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

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

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

@@ -0,0 +1,378 @@
+import { equal } from "@1771technologies/lytenyte-js-utils";
+import { makeAsyncTree } from "./async-tree/make-async-tree.js";
+import { RangeTree } from "./range-tree/range-tree.js";
+import { getRequestId } from "./utils/get-request-id.js";
+import { getNodePath } from "./utils/get-node-path.js";
+import { getNodeDepth } from "./utils/get-node-depth.js";
+const noopFetcher = async () => [];
+export class ServerData {
+    #tree;
+    #top = { asOf: 0, rows: [] };
+    #bottom = { asOf: 0, rows: [] };
+    #blocksize;
+    #flat;
+    #dataFetcher = noopFetcher;
+    #pivotMode;
+    #expansions;
+    #pivotExpansions;
+    #onResetLoadBegin;
+    #onResetLoadError;
+    #onResetLoadEnd;
+    #onFlatten;
+    #rowViewBounds = [0, 0];
+    #prevRequests = [];
+    #loadingRows = new Set();
+    #rowsWithError = new Map();
+    #controllers = new Set();
+    #defaultExpansion;
+    constructor({ blocksize, pivotMode, pivotExpansions, expansions, onResetLoadBegin, onResetLoadEnd, onResetLoadError, onFlatten, defaultExpansion, }) {
+        this.#tree = makeAsyncTree();
+        this.#blocksize = blocksize;
+        this.#pivotMode = pivotMode;
+        this.#expansions = expansions;
+        this.#pivotExpansions = pivotExpansions;
+        this.#defaultExpansion = defaultExpansion;
+        this.#onResetLoadBegin = onResetLoadBegin;
+        this.#onResetLoadEnd = onResetLoadEnd;
+        this.#onResetLoadError = onResetLoadError;
+        this.#onFlatten = onFlatten;
+    }
+    // Properties
+    set dataFetcher(d) {
+        if (this.#dataFetcher === d)
+            return;
+        this.#dataFetcher = d;
+        this.reset();
+    }
+    set pivotMode(b) {
+        if (b === this.#pivotMode)
+            return;
+        this.#pivotMode = b;
+        this.reset();
+    }
+    set expansions(d) {
+        this.#expansions = d;
+        if (this.#pivotMode)
+            return;
+        this.#flatten();
+    }
+    set pivotExpansions(d) {
+        this.#pivotExpansions = d;
+        if (!this.#pivotMode)
+            return;
+        this.#flatten();
+    }
+    set defaultExpansion(d) {
+        this.#defaultExpansion = d;
+    }
+    set rowViewBounds(viewBounds) {
+        if (equal(viewBounds, this.#rowViewBounds))
+            return;
+        this.#rowViewBounds = viewBounds;
+        this.handleViewBoundsChange();
+    }
+    // Methods
+    reset = async () => {
+        // Abort all the existing requests in flight.
+        this.#controllers.forEach((c) => c.abort());
+        this.#tree = makeAsyncTree();
+        this.#flatten();
+        try {
+            this.#onResetLoadBegin();
+            this.#prevRequests = [
+                {
+                    rowStartIndex: 0,
+                    rowEndIndex: this.#blocksize,
+                    id: getRequestId([], 0, this.#blocksize),
+                    path: [],
+                    start: 0,
+                    end: this.#blocksize,
+                },
+            ];
+            const res = await this.#dataFetcher(this.#prevRequests, this.#expansions, this.#pivotExpansions);
+            this.handleResponses(res);
+        }
+        catch (e) {
+            console.log(e);
+            this.#onResetLoadError(e);
+        }
+        finally {
+            this.#onResetLoadEnd();
+        }
+    };
+    handleRequests = async (requests, opts = {}) => {
+        const controller = new AbortController();
+        this.#controllers.add(controller);
+        const skip = opts.skipState ?? false;
+        // We need to request our new data now. There are a few scenarios to be aware. Once we are requesting rows,
+        // we should mark the rows loading. This means we mark the row indices as loading (maybe by range)?
+        // The load may fail, in which case we should mark the request as an error.
+        try {
+            // Mark these rows as loading
+            requests.forEach((req) => {
+                if (!skip)
+                    for (let i = req.rowStartIndex; i < req.rowEndIndex; i++)
+                        this.#loadingRows.add(i);
+            });
+            const responses = await this.#dataFetcher(requests, this.#expansions, this.#pivotExpansions);
+            // The request was aborted, so we can ignore it from this point
+            if (controller.signal.aborted)
+                return;
+            this.handleResponses(responses, () => {
+                if (!skip)
+                    requests.forEach((req) => {
+                        for (let i = req.rowStartIndex; i < req.rowEndIndex; i++)
+                            this.#rowsWithError.delete(i);
+                        for (let i = req.rowStartIndex; i < req.rowEndIndex; i++)
+                            this.#loadingRows.delete(i);
+                    });
+            });
+            opts?.onSuccess?.();
+        }
+        catch (e) {
+            if (controller.signal.aborted)
+                return;
+            opts?.onError?.(e);
+            if (!skip)
+                requests.forEach((req) => {
+                    for (let i = req.rowStartIndex; i < req.rowEndIndex; i++)
+                        this.#rowsWithError.set(i, e);
+                    for (let i = req.rowStartIndex; i < req.rowEndIndex; i++)
+                        this.#loadingRows.delete(i);
+                });
+        }
+        finally {
+            this.#controllers.delete(controller);
+        }
+    };
+    handleResponses = (data, beforeOnFlat) => {
+        const pinned = data.filter((c) => c.kind === "top" || c.kind === "bottom");
+        const center = data.filter((c) => c.kind !== "top" && c.kind !== "bottom");
+        // handle pinned
+        for (let i = 0; i < pinned.length; i++) {
+            const r = pinned[i];
+            if (r.kind === "top" && r.asOfTime > this.#top.asOf) {
+                this.#top = {
+                    asOf: r.asOfTime,
+                    rows: r.data.map((c) => ({ id: c.id, data: c.data, kind: "leaf" })),
+                };
+            }
+            else if (r.kind === "bottom" && r.asOfTime > this.#bottom.asOf) {
+                this.#bottom = {
+                    asOf: r.asOfTime,
+                    rows: r.data.map((c) => ({ id: c.id, data: c.data, kind: "leaf" })),
+                };
+            }
+        }
+        center.sort((l, r) => l.path.length - r.path.length);
+        for (let i = 0; i < center.length; i++) {
+            const r = center[i];
+            this.#tree.set({
+                path: r.path,
+                items: r.data.map((c, i) => {
+                    if (c.kind === "leaf") {
+                        return {
+                            kind: "leaf",
+                            data: {
+                                kind: "leaf",
+                                data: c.data,
+                                id: c.id,
+                            },
+                            relIndex: r.start + i,
+                        };
+                    }
+                    else {
+                        return {
+                            kind: "parent",
+                            data: {
+                                kind: "branch",
+                                data: c.data,
+                                depth: r.path.length,
+                                id: c.id,
+                                key: c.key,
+                            },
+                            path: c.key,
+                            relIndex: r.start + i,
+                            size: c.childCount,
+                        };
+                    }
+                }),
+                size: r.size,
+                asOf: r.asOfTime,
+            });
+        }
+        // Re-flatten our tree once everything has been re-updated.
+        this.#flatten(beforeOnFlat);
+    };
+    async handleViewBoundsChange() {
+        const [start, end] = this.#rowViewBounds;
+        const seen = new Set();
+        const requests = [];
+        for (let i = start; i < end; i++) {
+            const ranges = this.#flat.rangeTree.findRangesForRowIndex(i);
+            ranges.forEach((c) => {
+                if (c.parent.kind === "root") {
+                    const blockIndex = Math.floor(i / this.#blocksize);
+                    const start = blockIndex * this.#blocksize;
+                    const end = Math.min(start + this.#blocksize, c.parent.size);
+                    const path = [];
+                    const reqId = getRequestId(path, start, start + this.#blocksize);
+                    if (seen.has(reqId))
+                        return;
+                    seen.add(reqId);
+                    const size = start + this.#blocksize > c.parent.size ? c.parent.size - start : this.#blocksize;
+                    requests.push({ id: reqId, path, start, end, rowStartIndex: i, rowEndIndex: i + size });
+                }
+                else {
+                    const blockIndex = Math.floor((i - c.rowStart) / this.#blocksize);
+                    const start = blockIndex * this.#blocksize;
+                    const end = Math.min(start + this.#blocksize, c.parent.size);
+                    const path = getNodePath(c.parent);
+                    const reqId = getRequestId(path, start, start + this.#blocksize);
+                    if (seen.has(reqId))
+                        return;
+                    seen.add(reqId);
+                    const size = start + this.#blocksize > c.parent.size ? c.parent.size - start : this.#blocksize;
+                    requests.push({ id: reqId, path, start, end, rowStartIndex: i, rowEndIndex: i + size });
+                }
+            });
+        }
+        const newRequests = requests.filter((c) => !this.#prevRequests.find((prev) => prev.id === c.id));
+        // We don't have any new requests to make in our view, so we can return
+        if (!newRequests.length)
+            return;
+        this.#prevRequests = requests;
+        await this.handleRequests(newRequests);
+    }
+    updateRow(id, data) {
+        const centerRow = this.#flat.rowIdToTreeNode.get(id);
+        if (centerRow) {
+            centerRow.data = { ...centerRow.data, data };
+            return;
+        }
+        // Maybe its a pinned row?
+        const topIndex = this.#top.rows.findIndex((c) => c.id === id);
+        if (topIndex != -1) {
+            this.#top.rows[topIndex] = { ...this.#top.rows[topIndex], data };
+        }
+        const botIndex = this.#bottom.rows.findIndex((c) => c.id === id);
+        if (botIndex != -1) {
+            this.#top.rows[botIndex] = { ...this.#top.rows[botIndex], data };
+        }
+    }
+    #flatten = (beforeOnFlat) => {
+        const mode = this.#pivotMode;
+        const expansions = mode ? this.#pivotExpansions : this.#expansions;
+        const t = this.#tree;
+        const rowIdToRow = new Map();
+        const rowIndexToRow = new Map();
+        const rowIdToRowIndex = new Map();
+        const rowIdToTreeNode = new Map();
+        const ranges = [];
+        const blocksize = this.#blocksize;
+        const previousRequests = this.#prevRequests;
+        const withError = this.#rowsWithError;
+        const withLoading = this.#loadingRows;
+        const handleRequests = this.handleRequests;
+        const defaultExpansion = this.#defaultExpansion;
+        const postFlatRequests = [];
+        function processParent(node, start) {
+            const rows = [...node.byIndex.values()].sort((l, r) => l.relIndex - r.relIndex);
+            let offset = 0;
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                const rowIndex = row.relIndex + start + offset;
+                rowIndexToRow.set(rowIndex, row.data);
+                rowIdToRowIndex.set(row.data.id, rowIndex);
+                rowIdToRow.set(row.data.id, row.data);
+                rowIdToTreeNode.set(row.data.id, row);
+                if (row.kind === "parent") {
+                    const expanded = expansions[row.data.id] ??
+                        (typeof defaultExpansion === "number"
+                            ? getNodeDepth(row) <= defaultExpansion
+                            : defaultExpansion);
+                    if (expanded && !row.byIndex.size) {
+                        const path = getNodePath(row);
+                        const start = 0;
+                        const end = Math.min(start + blocksize, row.size);
+                        const reqSize = end - start;
+                        const req = {
+                            path,
+                            start: start,
+                            end: end,
+                            id: getRequestId(path, 0, blocksize),
+                            rowStartIndex: rowIndex + 1,
+                            rowEndIndex: rowIndex + 1 + reqSize,
+                        };
+                        // If we haven't already requested this node
+                        if (!previousRequests.find((c) => c.id === req.id)) {
+                            postFlatRequests.push([rowIndex, req]);
+                        }
+                    }
+                    else if (expanded) {
+                        offset += processParent(row, rowIndex + 1);
+                    }
+                }
+            }
+            ranges.push({
+                rowStart: start,
+                rowEnd: offset + node.size + start,
+                parent: node,
+            });
+            return offset + node.size;
+        }
+        const topCount = this.#top.rows.length;
+        const bottomCount = this.#bottom.rows.length;
+        for (let i = 0; i < topCount; i++) {
+            const row = this.#top.rows[i];
+            rowIndexToRow.set(i, row);
+            rowIdToRow.set(row.id, row);
+            rowIdToRowIndex.set(row.id, i);
+        }
+        const size = processParent(t, topCount);
+        for (let i = 0; i < bottomCount; i++) {
+            const row = this.#bottom.rows[i];
+            const rowIndex = i + size;
+            rowIndexToRow.set(rowIndex, row);
+            rowIdToRow.set(row.id, row);
+            rowIdToRowIndex.set(row.id, rowIndex);
+        }
+        const rangeTree = new RangeTree(ranges);
+        if (postFlatRequests.length > 0) {
+            postFlatRequests.forEach((c) => {
+                withLoading.add(c[0]);
+                previousRequests.push(c[1]);
+            });
+            const reqs = postFlatRequests.map((c) => c[1]);
+            handleRequests(reqs, {
+                skipState: true,
+                onError: (e) => {
+                    postFlatRequests.forEach((c) => {
+                        withLoading.delete(c[0]);
+                        withError.set(c[0], e);
+                    });
+                },
+                onSuccess: () => {
+                    postFlatRequests.forEach((c) => {
+                        withLoading.delete(c[0]);
+                    });
+                },
+            });
+        }
+        this.#flat = {
+            tree: t,
+            top: topCount,
+            center: size - topCount,
+            bottom: bottomCount,
+            rangeTree,
+            rowIndexToRow,
+            rowIdToRow,
+            rowIdToRowIndex,
+            rowIdToTreeNode,
+            errored: this.#rowsWithError,
+            loading: this.#loadingRows,
+        };
+        beforeOnFlat?.();
+        this.#onFlatten(this.#flat);
+    };
+}

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

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