@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-async-datasource.js

@@ -0,0 +1,329 @@
+import { __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
+import { log } from "@rowsncolumns/utils";
+import { produce } from "immer";
+import { startTransition, useCallback, useEffect, useRef, useState, } from "react";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+/**
+ * Infinite loader for Spreadsheet
+ *
+ * Usage:
+ *
+ *  const { onViewPortChange, isLoading } = useAsyncDatasource<CellData>({
+      sheetId: activeSheetId,
+      locale,
+      onChangeSheetData,
+      getRowData: useCallback(
+        async (sheetId, [rowStartIndex, rowStopIndex]) => {
+          console.log("fetching page", sheetId, [rowStartIndex, rowStopIndex]);
+          await new Promise((res) => setTimeout(res, 1000));
+          return [
+            null,
+            {
+              values: [
+                null,
+                {
+                  userEnteredValue: {
+                    formulaValue: "=SUM(E11,4)",
+                  },
+                },
+              ],
+            },
+          ];
+        },
+        []
+      ),
+    });
+ * @param param0
+ * @returns
+ */
+export var useAsyncDatasource = function (_a) {
+    var sheetId = _a.sheetId, locale = _a.locale, _b = _a.bufferPages, bufferPages = _b === void 0 ? 5 : _b, // Default to 5 pages
+    maxCachedPages = _a.maxCachedPages, _c = _a.pageSize, pageSize = _c === void 0 ? 100 : _c, // Optional fixed batch size
+    _d = _a.frozenRowCount, // Optional fixed batch size
+    frozenRowCount = _d === void 0 ? 0 : _d, rowCount = _a.rowCount, getRowData = _a.getRowData, onChangeSheetData = _a.onChangeSheetData;
+    var loadingRef = useRef(new Set());
+    var loadedPagesRef = useRef(new Map()); // Track loaded pages
+    var _e = __read(useState(false), 2), isLoading = _e[0], setIsLoading = _e[1];
+    var loadPage = useCallback(function (sheetId, page) { return __awaiter(void 0, void 0, void 0, function () {
+        var rowStartIndex, rowStopIndex, data, currentStart, currentMinPage, sheetCell, pagesToRemove, loadedPages, currentMinPage, currentMaxPage, viewportStartPage_1, viewportEndPage_1, keepPage0, loadedPages_1, loadedPages_1_1, loadedPage, pagesToRemoveSet_1, protectedPages_1, p, remainingPages, remainingCount, excess, distanceFromViewport_1, evictionCandidates, i, pagesToRemove_1, pagesToRemove_1_1, p;
+        var e_1, _a, e_2, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    // Don't skip if loadingRef has it, because multiple sheets can have same page index
+                    // We rely on caller to check loadingRef with sheetId scope
+                    log("Loading page", sheetId, page);
+                    if (pageSize === 0)
+                        return [2 /*return*/]; // Should not happen if batchSize is set or initialized
+                    rowStartIndex = page * pageSize;
+                    rowStopIndex = (page + 1) * pageSize;
+                    // Ensure we don't fetch beyond rowCount if provided
+                    if (rowCount !== undefined && rowStartIndex >= rowCount) {
+                        return [2 /*return*/];
+                    }
+                    // Add to cache AFTER check
+                    loadingRef.current.add("".concat(sheetId, ":").concat(page));
+                    // Set loading
+                    setIsLoading(true);
+                    return [4 /*yield*/, getRowData(sheetId, [rowStartIndex, rowStopIndex])];
+                case 1:
+                    data = _c.sent();
+                    // Optimization: Abort if the user has scrolled away from this page
+                    if (lastViewportRef.current) {
+                        currentStart = lastViewportRef.current.rowStartIndex;
+                        currentMinPage = Math.max(0, Math.floor(currentStart / pageSize));
+                        if (page < currentMinPage - bufferPages ||
+                            page > currentMinPage + bufferPages + 2) {
+                            log("Aborting outdated page load", sheetId, page);
+                            loadingRef.current.delete("".concat(sheetId, ":").concat(page));
+                            setIsLoading(false);
+                            return [2 /*return*/];
+                        }
+                    }
+                    sheetCell = new SheetCell();
+                    pagesToRemove = [];
+                    if (pageSize > 0) {
+                        if (!loadedPagesRef.current.has(sheetId)) {
+                            loadedPagesRef.current.set(sheetId, new Set());
+                        }
+                        loadedPages = loadedPagesRef.current.get(sheetId);
+                        loadedPages.add(page);
+                        currentMinPage = Math.max(0, page - bufferPages);
+                        currentMaxPage = page + bufferPages;
+                        viewportStartPage_1 = page;
+                        viewportEndPage_1 = page;
+                        if (lastViewportRef.current) {
+                            viewportStartPage_1 = Math.floor(lastViewportRef.current.rowStartIndex / pageSize);
+                            viewportEndPage_1 = Math.ceil(lastViewportRef.current.rowStopIndex / pageSize);
+                            currentMinPage = Math.max(0, viewportStartPage_1 - bufferPages);
+                            currentMaxPage = viewportEndPage_1 + bufferPages;
+                        }
+                        keepPage0 = frozenRowCount > 0;
+                        try {
+                            for (loadedPages_1 = __values(loadedPages), loadedPages_1_1 = loadedPages_1.next(); !loadedPages_1_1.done; loadedPages_1_1 = loadedPages_1.next()) {
+                                loadedPage = loadedPages_1_1.value;
+                                // If loadedPage contains frozen rows (page 0), keep it
+                                if (keepPage0 && loadedPage === 0)
+                                    continue;
+                                if (loadedPage < currentMinPage || loadedPage > currentMaxPage) {
+                                    pagesToRemove.push(loadedPage);
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (loadedPages_1_1 && !loadedPages_1_1.done && (_a = loadedPages_1.return)) _a.call(loadedPages_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        if (maxCachedPages && maxCachedPages > 0) {
+                            pagesToRemoveSet_1 = new Set(pagesToRemove);
+                            protectedPages_1 = new Set();
+                            for (p = viewportStartPage_1; p <= viewportEndPage_1; p++) {
+                                protectedPages_1.add(p);
+                            }
+                            protectedPages_1.add(page);
+                            if (keepPage0) {
+                                protectedPages_1.add(0);
+                            }
+                            remainingPages = Array.from(loadedPages).filter(function (p) { return !pagesToRemoveSet_1.has(p); });
+                            remainingCount = remainingPages.length;
+                            excess = remainingCount - maxCachedPages;
+                            if (excess > 0) {
+                                distanceFromViewport_1 = function (p) {
+                                    if (p < viewportStartPage_1)
+                                        return viewportStartPage_1 - p;
+                                    if (p > viewportEndPage_1)
+                                        return p - viewportEndPage_1;
+                                    return 0;
+                                };
+                                evictionCandidates = remainingPages
+                                    .filter(function (p) { return !protectedPages_1.has(p); })
+                                    .sort(function (a, b) {
+                                    var distanceDelta = distanceFromViewport_1(b) - distanceFromViewport_1(a);
+                                    if (distanceDelta !== 0)
+                                        return distanceDelta;
+                                    return b - a;
+                                });
+                                for (i = 0; i < evictionCandidates.length && i < excess; i++) {
+                                    pagesToRemoveSet_1.add(evictionCandidates[i]);
+                                }
+                            }
+                            pagesToRemove.length = 0;
+                            pagesToRemove.push.apply(pagesToRemove, __spreadArray([], __read(pagesToRemoveSet_1), false));
+                        }
+                        try {
+                            // Update Refs immediately (side effects belong here, not in reducer)
+                            for (pagesToRemove_1 = __values(pagesToRemove), pagesToRemove_1_1 = pagesToRemove_1.next(); !pagesToRemove_1_1.done; pagesToRemove_1_1 = pagesToRemove_1.next()) {
+                                p = pagesToRemove_1_1.value;
+                                loadedPages.delete(p);
+                                loadingRef.current.delete("".concat(sheetId, ":").concat(p));
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (pagesToRemove_1_1 && !pagesToRemove_1_1.done && (_b = pagesToRemove_1.return)) _b.call(pagesToRemove_1);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                    console.log("pagesToRemove", pagesToRemove);
+                    startTransition(function () {
+                        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                            var nextState = produce(prevSheetData, function (draft) {
+                                var e_3, _a;
+                                var _b, _c, _d, _e, _f, _g;
+                                try {
+                                    // 1. Eviction Logic
+                                    for (var pagesToRemove_2 = __values(pagesToRemove), pagesToRemove_2_1 = pagesToRemove_2.next(); !pagesToRemove_2_1.done; pagesToRemove_2_1 = pagesToRemove_2.next()) {
+                                        var p = pagesToRemove_2_1.value;
+                                        var removeStart = p * pageSize;
+                                        var removeEnd = (p + 1) * pageSize;
+                                        var sheet = draft[sheetId];
+                                        if (sheet) {
+                                            for (var r = removeStart; r < removeEnd; r++) {
+                                                delete sheet[r];
+                                            }
+                                        }
+                                    }
+                                }
+                                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                finally {
+                                    try {
+                                        if (pagesToRemove_2_1 && !pagesToRemove_2_1.done && (_a = pagesToRemove_2.return)) _a.call(pagesToRemove_2);
+                                    }
+                                    finally { if (e_3) throw e_3.error; }
+                                }
+                                // 2. Insert New Data
+                                for (var rowIndex = 0; rowIndex < ((_b = data === null || data === void 0 ? void 0 : data.length) !== null && _b !== void 0 ? _b : 0); rowIndex++) {
+                                    var dataRowIndex = rowStartIndex + rowIndex;
+                                    var currentSheet = createSheetDraft(draft, sheetId, dataRowIndex);
+                                    for (var columnIndex = 1; columnIndex < ((_e = (_d = (_c = data === null || data === void 0 ? void 0 : data[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0); columnIndex++) {
+                                        var cellData = (_g = (_f = data === null || data === void 0 ? void 0 : data[rowIndex]) === null || _f === void 0 ? void 0 : _f.values) === null || _g === void 0 ? void 0 : _g[columnIndex];
+                                        sheetCell.assign(sheetId, { rowIndex: dataRowIndex, columnIndex: columnIndex }, cellData, { locale: locale });
+                                        // Set cell data
+                                        currentSheet[dataRowIndex].values[columnIndex] =
+                                            sheetCell.getCellData();
+                                    }
+                                }
+                            });
+                            return nextState;
+                        });
+                    });
+                    // Reset
+                    setIsLoading(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [
+        onChangeSheetData,
+        getRowData,
+        pageSize,
+        locale,
+        frozenRowCount,
+        rowCount,
+        bufferPages,
+        maxCachedPages,
+    ]);
+    var lastViewportRef = useRef(null);
+    var onViewPortChange = useCallback(function (props) {
+        var rowStartIndex = props.rowStartIndex, rowStopIndex = props.rowStopIndex;
+        lastViewportRef.current = props;
+        if (pageSize <= 0)
+            return;
+        var firstPage = Math.max(0, Math.floor(rowStartIndex / pageSize));
+        var lastPage = Math.ceil(rowStopIndex / pageSize);
+        // Fetch pages in the viewport + buffer
+        var bufferStart = Math.max(0, firstPage - bufferPages);
+        var bufferEnd = lastPage + bufferPages;
+        for (var page = bufferStart; page < bufferEnd; page++) {
+            if (rowCount !== undefined && page * pageSize >= rowCount) {
+                continue;
+            }
+            if (loadingRef.current.has("".concat(sheetId, ":").concat(page))) {
+                continue;
+            }
+            loadPage(sheetId, page);
+        }
+    }, [loadPage, sheetId, pageSize, rowCount, bufferPages]);
+    // Trigger load when sheetId changes by re-using the last known viewport
+    useEffect(function () {
+        lastViewportRef.current = null;
+        loadPage(sheetId, 0);
+    }, [sheetId]);
+    /**
+     * Invalidate cache for a specific row and force re-fetch if it's currently loaded.
+     * Useful when background sync updates the underlying datasource.
+     */
+    var invalidate = useCallback(function (sheetId, rowIndex) {
+        var _a;
+        if (pageSize <= 0)
+            return;
+        var page = Math.floor(rowIndex / pageSize);
+        // Only re-fetch if we have tracked it as loaded or loading
+        // (If it's not loaded, it will be fetched when scrolled into view anyway)
+        if (loadingRef.current.has("".concat(sheetId, ":").concat(page))) {
+            log("Invalidating page", sheetId, page);
+            // Remove from cache tracking to allow re-fetch
+            loadingRef.current.delete("".concat(sheetId, ":").concat(page));
+            (_a = loadedPagesRef.current.get(sheetId)) === null || _a === void 0 ? void 0 : _a.delete(page);
+            // Clear the page data from state to ensure deletions are reflected
+            // onChangeSheetData?.((prevSheetData) => {
+            //   return produce(prevSheetData, (draft) => {
+            //     const sheet = draft[sheetId];
+            //     if (sheet) {
+            //       const start = page * pageSize;
+            //       const end = (page + 1) * pageSize;
+            //       for (let r = start; r < end; r++) {
+            //         delete sheet[r];
+            //       }
+            //     }
+            //   });
+            // });
+            // Trigger reload
+            loadPage(sheetId, page);
+        }
+    }, [pageSize, loadPage]);
+    /**
+     * Clears all cache and reloads the current viewport
+     */
+    var invalidateAll = useCallback(function (targetSheetId) {
+        var e_4, _a;
+        var id = targetSheetId;
+        // Clear loading refs for this sheet
+        var prefix = "".concat(id, ":");
+        try {
+            for (var _b = __values(loadingRef.current), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                if (key.startsWith(prefix)) {
+                    loadingRef.current.delete(key);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        // Clear loaded pages for this sheet
+        loadedPagesRef.current.delete(id);
+        // Clear state
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prev) {
+            return produce(prev, function (draft) {
+                delete draft[id];
+            });
+        });
+    }, [onChangeSheetData]);
+    return {
+        onViewPortChange: onViewPortChange,
+        isLoading: isLoading,
+        invalidate: invalidate,
+        invalidateAll: invalidateAll,
+        loadPage: loadPage,
+    };
+};

package/dist/cjs/hooks/use-calculation-initialize.d.ts

@@ -0,0 +1,61 @@
+import type { IterativeCalculationOptions } from "@rowsncolumns/common-types";
+import type { CellCoordinate } from "@rowsncolumns/dag";
+import type { CellData, ConditionalFormatRule, DataValidationRuleRecord, NamedRange } from "@rowsncolumns/spreadsheet";
+import { type CalculationOperation } from "./use-calculation";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { SheetData } from "./use-spreadsheet-state";
+/**
+ * Viewport information for viewport-based conditional format evaluation.
+ * Compatible with ViewPortProps from @rowsncolumns/grid.
+ */
+export type ViewportInfo = {
+    visibleRowStartIndex: number;
+    visibleRowStopIndex: number;
+    visibleColumnStartIndex: number;
+    visibleColumnStopIndex: number;
+};
+export type UseCalculationInitializeProps<T extends CellData> = {
+    sheetData?: SheetData<T>;
+    recalculateOnOpen?: boolean;
+    conditionalFormats?: ConditionalFormatRule[];
+    dataValidations?: DataValidationRuleRecord[];
+    activeSheetId?: number;
+    iterativeCalculation?: IterativeCalculationOptions;
+    getDataValidationById: ReturnType<typeof useSheetProperties>["getDataValidationById"];
+    enqueueCalculation(operation: CalculationOperation): void;
+    enqueueGraphOperation(operation: CalculationOperation): void;
+    onResetCalculator?(): void;
+    /** Get current viewport for viewport-based CF/DV evaluation */
+    getViewPort?(): ViewportInfo | undefined;
+    /**
+     * Phase 9 — workbook's named ranges. Passed through to
+     * `applyNamedRanges` at the top of each calculate sweep so the
+     * calculator's named-range registrations match the latest list
+     * before any cell formula is parsed. Without this, cells
+     * referencing a named range would be parsed as `#NAME?` and no
+     * DAG edge would form to the named-range static node.
+     */
+    namedRanges?: NamedRange[];
+    /**
+     * Phase 9 — registers `namedRanges` with the calculator. Excel
+     * applies defined names workbook-wide before any cell evaluates;
+     * this hook gives us the same ordering guarantee. Invoked at the
+     * top of `calculate()` with the current `namedRanges` prop.
+     */
+    applyNamedRanges?(list: NamedRange[] | undefined): void;
+};
+export type CalculateNowOptions = {
+    shouldResetCellDependencyGraph?: boolean;
+    disableEvaluation?: boolean;
+};
+export declare const useCalculationInitialize: <T extends CellData>({ sheetData, conditionalFormats: initialConditionalFormats, dataValidations: initialDataValidations, recalculateOnOpen, activeSheetId, iterativeCalculation, getDataValidationById, enqueueCalculation, enqueueGraphOperation, onResetCalculator, getViewPort, namedRanges, applyNamedRanges, }: UseCalculationInitializeProps<T>) => {
+    calculateNow: (options?: CalculateNowOptions) => Promise<void>;
+    evaluateConditionalFormatting: (conditionalFormats?: ConditionalFormatRule[], viewport?: ViewportInfo, disableEvaluation?: boolean) => void;
+    evaluateDataValidations: (dataValidations?: DataValidationRuleRecord[], viewport?: ViewportInfo, disableEvaluation?: boolean) => void;
+    evaluateConditionalFormattingForViewport: (viewport: ViewportInfo, conditionalFormats?: ConditionalFormatRule[]) => void;
+    evaluateDataValidationsForViewport: (viewport: ViewportInfo, dataValidations?: DataValidationRuleRecord[]) => void;
+    clearEvaluatedCellsCache: () => void;
+    onViewPortChange: (viewport: ViewportInfo) => void;
+    reevaluateDerivationsForCells: (cells: Array<Pick<CellCoordinate, "sheetId" | "rowIndex" | "columnIndex">>) => void;
+};
+//# sourceMappingURL=use-calculation-initialize.d.ts.map

package/dist/cjs/hooks/use-calculation-initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-calculation-initialize.d.ts","sourceRoot":"","sources":["../../../hooks/use-calculation-initialize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EACV,QAAQ,EACR,qBAAqB,EACrB,wBAAwB,EACxB,UAAU,EACX,MAAM,2BAA2B,CAAC;AAkBnC,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,uBAAuB,EAAE,MAAM,CAAC;IAChC,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,6BAA6B,CAAC,CAAC,SAAS,QAAQ,IAAI;IAC9D,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAC7C,eAAe,CAAC,EAAE,wBAAwB,EAAE,CAAC;IAC7C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oBAAoB,CAAC,EAAE,2BAA2B,CAAC;IACnD,qBAAqB,EAAE,UAAU,CAC/B,OAAO,kBAAkB,CAC1B,CAAC,uBAAuB,CAAC,CAAC;IAC3B,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC1D,qBAAqB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC7D,iBAAiB,CAAC,IAAI,IAAI,CAAC;IAC3B,+DAA+D;IAC/D,WAAW,CAAC,IAAI,YAAY,GAAG,SAAS,CAAC;IACzC;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B;;;;;OAKG;IACH,gBAAgB,CAAC,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,SAAS,GAAG,IAAI,CAAC;CACzD,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,8BAA8B,CAAC,EAAE,OAAO,CAAC;IACzC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAkJF,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,QAAQ,EAAE,iSAc1D,6BAA6B,CAAC,CAAC,CAAC;6BAmGrB,mBAAmB,KAAQ,OAAO,CAAC,IAAI,CAAC;yDA4C3B,qBAAqB,EAAE,aACjC,YAAY,sBACH,OAAO;gDA+DT,wBAAwB,EAAE,aACjC,YAAY,sBACH,OAAO;yDAiNlB,YAAY,uBAAuB,qBAAqB,EAAE;mDAuD1D,YAAY,oBAAoB,wBAAwB,EAAE;;iCAsHxD,YAAY;2CAvDd,KAAK,CACV,IAAI,CAAC,cAAc,EAAE,SAAS,GAAG,UAAU,GAAG,aAAa,CAAC,CAC7D;CAmHR,CAAC"}