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

package/dist/data-source-server/source/use-row-by-index.js

@@ -0,0 +1,89 @@
+import { useMemo, useRef } from "react";
+import { createSignal, isRowIndeterminate, isRowSelected, useEvent, useSelector, } from "@1771technologies/lytenyte-core/internal";
+export function useRowByIndex(source, state, globalSignal, getParents) {
+    const invalidateCacheRef = useRef(new Map());
+    const atomCacheRef = useRef({});
+    const loadingCache = useRef({});
+    const rowInvalidate = useEvent((row) => {
+        if (row == null) {
+            globalSignal(Date.now());
+        }
+        else {
+            const invalidate = invalidateCacheRef.current.get(row);
+            invalidate?.(Date.now());
+        }
+    });
+    const rowByIndex = useEvent((i) => {
+        const atomCache = atomCacheRef.current;
+        const invalidateCache = invalidateCacheRef.current;
+        if (!atomCache[i]) {
+            const signal = createSignal(Date.now());
+            invalidateCache.set(i, signal);
+            atomCache[i] = {
+                get: () => source.flat.rowIndexToRow.get(i) ?? null,
+                useValue: () => {
+                    // Invalidate is used to invalidate an individual row, and the global signal will invalidate all rows.
+                    const localSnapshot = useSelector(signal);
+                    const globalSnapshot = useSelector(globalSignal);
+                    const flat = source.flat;
+                    const row = flat.rowIndexToRow.get(i);
+                    const isLoading = flat.loading.has(i);
+                    const isGroupLoading = flat.loadingGroup.has(i);
+                    const errorGroup = flat.erroredGroup.get(i);
+                    const error = flat.errored.get(i);
+                    const [selected, indeterminate] = useMemo(() => {
+                        void localSnapshot;
+                        void globalSnapshot;
+                        if (!row)
+                            return [false, false];
+                        const selected = isRowSelected(row.id, state.rowSelections, getParents);
+                        const indeterminate = !selected &&
+                            row.kind === "branch" &&
+                            isRowIndeterminate(row.id, state.rowSelections, getParents);
+                        return [selected, indeterminate];
+                    }, [row, localSnapshot, globalSnapshot]);
+                    if (!row) {
+                        if (!loadingCache.current[i]) {
+                            loadingCache.current[i] = {
+                                id: `__loading__placeholder__${i}`,
+                                data: null,
+                                kind: "leaf",
+                                loading: true,
+                                error: error?.error,
+                                depth: 0,
+                            };
+                        }
+                        const loadingRow = loadingCache.current[i];
+                        Object.assign(loadingRow, { loading: true, error: error?.error });
+                        return loadingRow;
+                    }
+                    if (row.kind === "leaf" || row.kind === "aggregated") {
+                        Object.assign(row, {
+                            loading: isLoading,
+                            error: error?.error,
+                            __indeterminate: indeterminate,
+                            __selected: selected,
+                            __localSnapshot: localSnapshot,
+                            __globalSnapshot: globalSnapshot,
+                        });
+                    }
+                    else if (row.kind === "branch") {
+                        Object.assign(row, {
+                            loading: isLoading,
+                            error: error?.error,
+                            errorGroup: errorGroup?.error,
+                            loadingGroup: isGroupLoading,
+                            __indeterminate: indeterminate,
+                            __selected: selected,
+                            __localSnapshot: localSnapshot,
+                            __globalSnapshot: globalSnapshot,
+                        });
+                    }
+                    return row;
+                },
+            };
+        }
+        return atomCache[i];
+    });
+    return { rowInvalidate, rowByIndex };
+}

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

@@ -0,0 +1,2 @@
+import type { ServerData } from "../server-data";
+export declare function useRowChildren<T>(source: ServerData): (id: string) => string[];

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

@@ -0,0 +1,16 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowChildren(source) {
+    const rowChildren = useEvent((id) => {
+        const node = source.tree.rowIdToNode.get(id);
+        if (!node)
+            return [];
+        if (node.kind === "leaf")
+            return [];
+        const ids = [];
+        node.byIndex.forEach((n) => {
+            ids.push(n.row.id);
+        });
+        return ids;
+    });
+    return rowChildren;
+}

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

@@ -0,0 +1,3 @@
+import type { ServerData } from "../server-data";
+import type { UseServerDataSourceParams } from "../use-server-data-source";
+export declare function useRowDelete<T>(source: ServerData, onRowDelete: UseServerDataSourceParams<any, unknown[]>["onRowsDeleted"], optimistic?: boolean): (rows: import("@1771technologies/lytenyte-shared").RowNode<T>[]) => void;

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

@@ -0,0 +1,39 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowDelete(source, onRowDelete, optimistic = false) {
+    const rowDelete = useEvent((rows) => {
+        if (!onRowDelete || !rows.length)
+            return null;
+        if (!optimistic) {
+            onRowDelete({ rows });
+            return;
+        }
+        const rollbackNodes = [];
+        const startDeletes = [];
+        const endDeletes = [];
+        rows.forEach((x) => {
+            const node = source.tree.rowIdToNode.get(x.id);
+            if (node && node.kind === "leaf" && node.optimistic) {
+                if (node.optimistic === "start")
+                    startDeletes.push(node.row.id);
+                else
+                    endDeletes.push(node.row.id);
+                return;
+            }
+            if (node)
+                node.deleted = true;
+            rollbackNodes.push(node);
+        });
+        if (startDeletes.length)
+            source.deleteBefore(startDeletes);
+        if (endDeletes.length)
+            source.deleteAfter(endDeletes);
+        onRowDelete({ rows }).catch(() => {
+            rollbackNodes.forEach((x) => {
+                delete x.deleted;
+            });
+            source.flatten();
+        });
+        source.flatten();
+    });
+    return rowDelete;
+}

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

@@ -0,0 +1,2 @@
+import type { ServerData } from "../server-data.js";
+export declare function useRowIdToRowIndex<T>(source: ServerData): (id: string) => number | null | undefined;

package/dist/data-source-server/source/use-row-id-to-row-index.js

@@ -0,0 +1,7 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowIdToRowIndex(source) {
+    const rowIdToRowIndex = useEvent((id) => {
+        return source.flat.rowIdToRowIndex.get(id) ?? null;
+    });
+    return rowIdToRowIndex;
+}

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

@@ -0,0 +1,2 @@
+import type { ServerData } from "../server-data";
+export declare function useRowIndexToRowId<T>(source: ServerData): (index: number) => string | null | undefined;

package/dist/data-source-server/source/use-row-index-to-row-id.js

@@ -0,0 +1,7 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowIndexToRowId(source) {
+    const rowIndexToRowId = useEvent((index) => {
+        return source.flat.rowIndexToRow.get(index)?.id ?? null;
+    });
+    return rowIndexToRowId;
+}

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

@@ -0,0 +1,2 @@
+import type { ServerData } from "../server-data";
+export declare function useRowLeafs<T>(source: ServerData): (id: string) => string[];

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

@@ -0,0 +1,20 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowLeafs(source) {
+    const rowLeafs = useEvent((id) => {
+        const node = source.tree.rowIdToNode.get(id);
+        if (!node || node.kind === "leaf")
+            return [];
+        const rows = [];
+        const stack = [...node.byIndex.values()];
+        while (stack.length) {
+            const next = stack.pop();
+            if (next.kind === "leaf")
+                rows.push(next.row.id);
+            else {
+                stack.push(...next.byIndex.values());
+            }
+        }
+        return rows;
+    });
+    return rowLeafs;
+}

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

@@ -0,0 +1,2 @@
+import type { ServerData } from "../server-data";
+export declare function useRowParents<T>(source: ServerData): (id: string) => string[];

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

@@ -0,0 +1,16 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowParents(source) {
+    const rowParents = useEvent((id) => {
+        const node = source.tree.rowIdToNode.get(id);
+        if (!node)
+            return [];
+        const parents = [];
+        let current = node.parent;
+        while (current && current.kind !== "root") {
+            parents.push(current.row.id);
+            current = current.parent;
+        }
+        return parents.reverse();
+    });
+    return rowParents;
+}

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

@@ -0,0 +1,2 @@
+import type { ServerData } from "../server-data";
+export declare function useRowSiblings<T>(source: ServerData): (id: string) => string[];

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

@@ -0,0 +1,15 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowSiblings(source) {
+    const rowChildren = useEvent((id) => {
+        const node = source.tree.rowIdToNode.get(id);
+        const parent = node?.parent;
+        if (!parent)
+            return [];
+        const ids = [];
+        parent.byIndex.forEach((n) => {
+            ids.push(n.row.id);
+        });
+        return ids;
+    });
+    return rowChildren;
+}

package/dist/data-source-server/source/use-rows-between.d.ts

@@ -0,0 +1,2 @@
+import type { ServerData } from "../server-data";
+export declare function useRowsBetween<T>(source: ServerData): (start: string, end: string) => string[];

package/dist/data-source-server/source/use-rows-between.js

@@ -0,0 +1,20 @@
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useRowsBetween(source) {
+    const rowsBetween = useEvent((startId, endId) => {
+        const left = source.flat.rowIdToRowIndex.get(startId);
+        const right = source.flat.rowIdToRowIndex.get(endId);
+        if (left == null || right == null)
+            return [];
+        const start = Math.min(left, right);
+        const end = Math.max(left, right);
+        const ids = [];
+        for (let i = start; i <= end + 1; i++) {
+            const row = source.flat.rowIndexToRow.get(i);
+            if (!row)
+                continue;
+            ids.push(row.id);
+        }
+        return ids;
+    });
+    return rowsBetween;
+}

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

@@ -0,0 +1,28 @@
+import type { DataRequest } from "../types";
+import type { UseServerDataSourceParams } from "../use-server-data-source";
+import type { RowNode } from "@1771technologies/lytenyte-shared";
+export type SourceState = ReturnType<typeof useSourceState>;
+export declare function useSourceState<K extends unknown[]>(props: UseServerDataSourceParams<any, K>): {
+    isLoading: boolean;
+    setIsLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    loadingError: unknown;
+    setLoadingError: import("react").Dispatch<unknown>;
+    requestsForView: DataRequest[];
+    setRequestsForView: import("react").Dispatch<import("react").SetStateAction<DataRequest[]>>;
+    topCount: number;
+    setTopCount: import("react").Dispatch<import("react").SetStateAction<number>>;
+    botCount: number;
+    setBotCount: import("react").Dispatch<import("react").SetStateAction<number>>;
+    rowCount: number;
+    setRowCount: import("react").Dispatch<import("react").SetStateAction<number>>;
+    expansions: {
+        [rowId: string]: boolean | undefined;
+    };
+    onExpansionsChange: (delta: Record<string, boolean | undefined>) => void;
+    maxDepth: number;
+    setMaxDepth: import("react").Dispatch<import("react").SetStateAction<number>>;
+    rows: Map<number, RowNode<any>>;
+    setRows: import("react").Dispatch<import("react").SetStateAction<Map<number, RowNode<any>>>>;
+    idUniverse: Set<string>;
+    setIdUniverse: import("react").Dispatch<import("react").SetStateAction<Set<string>>>;
+};

package/dist/data-source-server/source/use-source-state.js

@@ -0,0 +1,47 @@
+import { useRef, useState } from "react";
+import { useControlled, useEvent } from "@1771technologies/lytenyte-core/internal";
+export function useSourceState(props) {
+    const [rows, setRows] = useState(new Map());
+    const [maxDepth, setMaxDepth] = useState(0);
+    const [isLoading, setIsLoading] = useState(false);
+    const [loadingError, setLoadingError] = useState(null);
+    const [requestsForView, setRequestsForView] = useState([]);
+    const [idUniverse, setIdUniverse] = useState(new Set());
+    const [topCount, setTopCount] = useState(0);
+    const [rowCount, setRowCount] = useState(0);
+    const [botCount, setBotCount] = useState(0);
+    const [expansions, setExpansions] = useControlled({
+        controlled: props.rowGroupExpansions,
+        default: {},
+    });
+    const onExpansionsChange = useEvent((delta) => {
+        setExpansions({ ...expansions, ...delta });
+        props.onRowGroupExpansionChange?.({ ...expansions, ...delta });
+    });
+    const state = {
+        isLoading,
+        setIsLoading,
+        loadingError,
+        setLoadingError,
+        requestsForView,
+        setRequestsForView,
+        topCount,
+        setTopCount,
+        botCount,
+        setBotCount,
+        rowCount,
+        setRowCount,
+        expansions,
+        onExpansionsChange,
+        maxDepth,
+        setMaxDepth,
+        rows,
+        setRows,
+        idUniverse,
+        setIdUniverse,
+    };
+    // React is stupid sometimes.
+    const stateRef = useRef(state);
+    Object.assign(stateRef.current, state);
+    return stateRef.current;
+}

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

@@ -0,0 +1,5 @@
+import type { UseServerDataSourceParams } from "../use-server-data-source";
+import { type Signal } from "@1771technologies/lytenyte-core/internal";
+import { ServerData } from "../server-data.js";
+import type { SourceState } from "./use-source-state";
+export declare function useSource<K extends unknown[]>(props: UseServerDataSourceParams<any, K>, s: SourceState, globalSignal: Signal<number>): ServerData;

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

@@ -0,0 +1,66 @@
+import { useEffect, useMemo, useRef } from "react";
+import { arrayShallow } from "@1771technologies/lytenyte-shared";
+import { useEvent } from "@1771technologies/lytenyte-core/internal";
+import { ServerData } from "../server-data.js";
+export function useSource(props, s, globalSignal) {
+    const prevQueryKeyRef = useRef(null);
+    const queryKey = useMemo(() => {
+        const current = prevQueryKeyRef.current;
+        if (!current) {
+            prevQueryKeyRef.current = props.queryKey;
+            return prevQueryKeyRef.current;
+        }
+        if (!arrayShallow(current, props.queryKey)) {
+            prevQueryKeyRef.current = props.queryKey;
+        }
+        return prevQueryKeyRef.current;
+    }, [props.queryKey]);
+    const queryFn = useEvent(props.queryFn);
+    const dataFetcher = useMemo(() => {
+        const fetcher = (req, expansions) => {
+            const model = { rowGroupExpansions: expansions };
+            return queryFn({ model, queryKey, reqTime: Date.now(), requests: req });
+        };
+        return fetcher;
+    }, [queryFn, queryKey]);
+    const sourceRef = useRef(null);
+    if (!sourceRef.current) {
+        sourceRef.current = new ServerData({
+            defaultExpansion: props.rowGroupDefaultExpansion ?? false,
+            blocksize: props.blockSize ?? 200,
+            expansions: s.expansions,
+            onResetLoadBegin: () => {
+                s.setIsLoading(true);
+                s.setLoadingError(null);
+            },
+            // I know what I am about. This is fine, we only care the global signal has changed.
+            // eslint-disable-next-line react-hooks/purity
+            onInvalidate: () => globalSignal(Date.now()),
+            onResetLoadEnd: () => s.setIsLoading(false),
+            onResetLoadError: (e) => s.setLoadingError(e),
+            onFlatten: (f) => {
+                s.setTopCount(f.top);
+                s.setBotCount(f.bottom);
+                s.setRowCount(f.center + f.top + f.bottom);
+                s.setMaxDepth(f.maxDepth);
+                s.setRows(f.rowIndexToRow);
+                s.setIdUniverse(new Set(f.tree.rowIdToNode.keys()));
+                // Not sure why this is being flagged. This is not being used in hook. This is also fine. We don't
+                // actually care about the value, just that it will be different from the previous value.
+                // eslint-disable-next-line react-hooks/purity
+                globalSignal(Date.now());
+            },
+        });
+    }
+    useEffect(() => {
+        sourceRef.current.dataFetcher = dataFetcher;
+    }, [dataFetcher]);
+    const prevExpansions = useRef(s.expansions);
+    useEffect(() => {
+        if (prevExpansions.current === s.expansions)
+            return;
+        prevExpansions.current = s.expansions;
+        sourceRef.current.expansions = s.expansions;
+    }, [s.expansions]);
+    return sourceRef.current;
+}

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

@@ -0,0 +1,42 @@
+export interface DataRequest {
+    readonly id: string;
+    readonly path: (string | null)[];
+    readonly start: number;
+    readonly end: number;
+    readonly rowStartIndex: number;
+    readonly rowEndIndex: number;
+}
+export interface DataResponse {
+    readonly kind: "center";
+    readonly data: (DataResponseLeafItem | DataResponseBranchItem)[];
+    readonly size: number;
+    readonly asOfTime: number;
+    readonly path: (string | null)[];
+    readonly start: number;
+    readonly end: number;
+}
+export interface DataResponseBranchItem {
+    readonly kind: "branch";
+    readonly id: string;
+    readonly data: any;
+    readonly key: string | null;
+    readonly childCount: number;
+}
+export interface DataResponseLeafItem {
+    readonly kind: "leaf";
+    readonly id: string;
+    readonly data: any;
+}
+export interface DataResponsePinned {
+    readonly kind: "top" | "bottom";
+    readonly data: DataResponseLeafItem[];
+    readonly asOfTime: number;
+}
+export interface QueryFnParams<K extends unknown[]> {
+    readonly queryKey: K;
+    readonly requests: DataRequest[];
+    readonly reqTime: number;
+    readonly model: {
+        readonly rowGroupExpansions: Record<string, boolean | undefined>;
+    };
+}

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

@@ -0,0 +1,51 @@
+import type { DataRequest, DataResponse, DataResponsePinned, QueryFnParams } from "./types";
+import { type Piece } from "@1771technologies/lytenyte-core/internal";
+import { type RowGroup, type RowLeaf, type RowNode, type RowSelectionState, type RowSource } from "@1771technologies/lytenyte-shared";
+export interface RowSourceServer<T> extends RowSource<T> {
+    readonly isLoading: Piece<boolean>;
+    readonly loadingError: Piece<unknown>;
+    readonly requestsForView: Piece<DataRequest[]>;
+    readonly seenRequests: Set<string>;
+    readonly retry: () => void;
+    readonly requestForGroup: (row: RowGroup | number) => DataRequest | null;
+    readonly requestForNextSlice: (currentRequest: DataRequest) => DataRequest | null;
+    readonly refresh: (onSuccess?: () => void, onError?: (e: unknown) => void) => void;
+    readonly pushResponses: (req: (DataResponse | DataResponsePinned)[]) => void;
+    readonly pushRequests: (req: DataRequest[], onSuccess?: () => void, onError?: (e: unknown) => void) => void;
+    readonly reset: () => void;
+    readonly rowAdd: (rows: RowLeaf<T>[], placement?: "start" | "end") => void;
+    readonly rowDelete: (rows: RowNode<T>[]) => void;
+    readonly rowUpdate: (rows: Map<RowNode<T>, T>) => void;
+}
+export interface UseServerDataSourceParams<T = any, K extends unknown[] = any[]> {
+    readonly queryFn: (params: QueryFnParams<K>) => Promise<(DataResponse | DataResponsePinned)[]>;
+    readonly queryKey: K;
+    readonly blockSize?: number;
+    readonly rowGroupExpansions?: {
+        [rowId: string]: boolean | undefined;
+    };
+    readonly rowGroupDefaultExpansion?: boolean | number;
+    readonly onRowGroupExpansionChange?: (state: Record<string, boolean | undefined>) => void;
+    readonly rowsIsolatedSelection?: boolean;
+    readonly rowSelection?: RowSelectionState;
+    readonly rowSelectionIdUniverseAdditions?: {
+        readonly id: string;
+        readonly root: boolean;
+    }[];
+    readonly rowSelectionIdUniverseSubtractions?: Set<string>;
+    readonly onRowSelectionChange?: (state: RowSelectionState) => void;
+    readonly rowSelectKey?: unknown[];
+    readonly hasRowBranches?: "infer" | boolean;
+    readonly rowUpdateOptimistically?: boolean;
+    readonly onRowDataChange?: (params: {
+        readonly rows: Map<RowNode<T>, T>;
+    }) => Promise<void>;
+    readonly onRowsDeleted?: (params: {
+        readonly rows: RowNode<T>[];
+    }) => Promise<void>;
+    readonly onRowsAdded?: (params: {
+        readonly rows: RowLeaf<T>[];
+        placement: "start" | "end";
+    }) => Promise<void>;
+}
+export declare function useServerDataSource<T, K extends unknown[] = unknown[]>(props: UseServerDataSourceParams<T, K>): RowSourceServer<T>;