@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/calculation-interface.js

@@ -0,0 +1,409 @@
+import { __awaiter, __generator } from "tslib";
+import { CalculationGraph, CalculationWorkerClient, createNamedRangeResolver, createStructuredReferenceResolver, enqueueCalculationOperations, mapOperationToGraphOperation, } from "@rowsncolumns/calculation-worker/server";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+var isSerializedFormulaError = function (value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        "type" in value &&
+        value.type === "FormulaError");
+};
+var deserializeWorkerValue = function (value) {
+    var _a;
+    if (isSerializedFormulaError(value)) {
+        var details = typeof value.details === "string"
+            ? value.details
+            : (_a = value.details) === null || _a === void 0 ? void 0 : _a.reason;
+        return new FormulaError(value.error, details);
+    }
+    if (Array.isArray(value)) {
+        return value.map(function (entry) {
+            return Array.isArray(entry)
+                ? entry.map(function (child) {
+                    return deserializeWorkerValue(child);
+                })
+                : deserializeWorkerValue(entry);
+        });
+    }
+    return value;
+};
+var normalizeMatrixValue = function (value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    if (!value.length) {
+        return [[undefined]];
+    }
+    if (Array.isArray(value[0])) {
+        return value;
+    }
+    return [value];
+};
+var expandWorkerResult = function (result) {
+    var _a;
+    if (!result.position) {
+        return [];
+    }
+    var position = result.position;
+    var resolvedValue = deserializeWorkerValue(result.value);
+    var matrix = normalizeMatrixValue(resolvedValue);
+    if (!matrix) {
+        return [[position, resolvedValue]];
+    }
+    var entries = [];
+    for (var rowOffset = 0; rowOffset < matrix.length; rowOffset += 1) {
+        var row = (_a = matrix[rowOffset]) !== null && _a !== void 0 ? _a : [];
+        for (var colOffset = 0; colOffset < row.length; colOffset += 1) {
+            entries.push([
+                {
+                    sheetId: position.sheetId,
+                    rowIndex: position.rowIndex + rowOffset,
+                    columnIndex: position.columnIndex + colOffset,
+                },
+                row[colOffset],
+            ]);
+        }
+    }
+    return entries;
+};
+var CalculationInterface = /** @class */ (function () {
+    function CalculationInterface(options) {
+        var _this = this;
+        var _a, _b;
+        this.options = options;
+        this.operationQueue = [];
+        this.graphOperationQueue = [];
+        this.flushScheduled = false;
+        this.graphFlushScheduled = false;
+        this.metadataDirty = true;
+        this.lastMetadataSignature = "";
+        this.pendingFlush = Promise.resolve();
+        this.enqueueCalculation = function (operation) {
+            _this.operationQueue.push(operation);
+        };
+        this.enqueueGraphOperation = function (operation) {
+            _this.graphOperationQueue.push(operation);
+        };
+        this.enqueueStructureChange = function (_change) {
+            // Worker calculation uses per-batch range caches, so no persistent
+            // calculator range cache needs explicit structural invalidation here.
+        };
+        this.markMetadataDirty = function () {
+            _this.metadataDirty = true;
+        };
+        var structuredReferenceResolver = createStructuredReferenceResolver({
+            getTables: function () { return options.getTables(); },
+            getSheetName: function (sheetId) { return options.getSheetName(sheetId); },
+            getSheetId: function (sheetName) {
+                return sheetName ? options.getSheetId(sheetName) : undefined;
+            },
+        });
+        var namedRangeResolver = createNamedRangeResolver({
+            getNamedRanges: function () { return options.getNamedRanges(); },
+            getSheetName: function (sheetId) { return options.getSheetName(sheetId); },
+        });
+        this.graph = new CalculationGraph({
+            getSheetId: function (sheetName) { return options.getSheetId(sheetName); },
+            getSheetName: function (sheetId) { return options.getSheetName(sheetId); },
+            getFormula: function (position) { return options.getFinalUserEnteredValue(position); },
+            getCellValue: function (position, property) {
+                var value = options.getEffectiveValue(position.sheetId, position.rowIndex, position.columnIndex, property);
+                if (property && options.getEffectiveStructuredValue) {
+                    return options.getEffectiveStructuredValue(value, property);
+                }
+                return value;
+            },
+            depParserConfig: {
+                onStructuredReference: structuredReferenceResolver,
+                onVariable: namedRangeResolver,
+            },
+            iterativeCalculation: options.iterativeCalculation,
+        });
+        var worker = this.ensureWorker((_b = (_a = options.createWorker) === null || _a === void 0 ? void 0 : _a.call(options)) !== null && _b !== void 0 ? _b : this.createDefaultWorker());
+        this.workerClient = new CalculationWorkerClient({
+            worker: worker,
+            enableNumericMatrixTransfer: true,
+        });
+    }
+    CalculationInterface.prototype.getDependents = function (source) {
+        return this.graph.getDependents(source);
+    };
+    CalculationInterface.prototype.getPrecedents = function (source) {
+        return this.graph.getPrecedents(source);
+    };
+    CalculationInterface.prototype.getNodes = function () {
+        return this.graph.getNodes();
+    };
+    CalculationInterface.prototype.getNodesInSheet = function (sheetId) {
+        return this.graph.getNodesInSheet(sheetId);
+    };
+    CalculationInterface.prototype.flush = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var operations, run;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!this.operationQueue.length) {
+                    return [2 /*return*/, this.pendingFlush];
+                }
+                operations = this.operationQueue;
+                this.operationQueue = [];
+                run = function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, this.executeOperations(operations)];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); };
+                this.pendingFlush = this.pendingFlush.then(run, run);
+                return [2 /*return*/, this.pendingFlush];
+            });
+        });
+    };
+    CalculationInterface.prototype.flushWithResults = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var operations, run, pending;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!this.operationQueue.length) {
+                    return [2 /*return*/, []];
+                }
+                operations = this.operationQueue;
+                this.operationQueue = [];
+                run = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                    return [2 /*return*/, this.executeOperations(operations)];
+                }); }); };
+                pending = this.pendingFlush.then(run, run);
+                this.pendingFlush = pending.then(function () { return undefined; }, function () { return undefined; });
+                return [2 /*return*/, pending];
+            });
+        });
+    };
+    CalculationInterface.prototype.calculate = function (operations) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!operations.length) {
+                    return [2 /*return*/, []];
+                }
+                return [2 /*return*/, this.executeOperations(operations)];
+            });
+        });
+    };
+    CalculationInterface.prototype.rebuildGraph = function (operations) {
+        var _this = this;
+        this.graph.reset();
+        var graphOperations = operations
+            .map(function (operation) {
+            return mapOperationToGraphOperation(operation, function (op) {
+                var value = _this.options.getFinalUserEnteredValue(op.position);
+                return typeof value === "string" ? value : undefined;
+            });
+        })
+            .filter(function (op) {
+            return Boolean(op);
+        });
+        if (!graphOperations.length) {
+            return;
+        }
+        this.graph.applyGraphOperations(graphOperations);
+    };
+    CalculationInterface.prototype.dispose = function () {
+        this.workerClient.dispose();
+    };
+    CalculationInterface.prototype.scheduleFlush = function () {
+        var _this = this;
+        if (this.flushScheduled) {
+            return;
+        }
+        this.flushScheduled = true;
+        queueMicrotask(function () {
+            _this.flushScheduled = false;
+            void _this.flush();
+        });
+    };
+    CalculationInterface.prototype.scheduleGraphFlush = function () {
+        var _this = this;
+        if (this.graphFlushScheduled) {
+            return;
+        }
+        this.graphFlushScheduled = true;
+        queueMicrotask(function () {
+            _this.graphFlushScheduled = false;
+            if (!_this.graphOperationQueue.length) {
+                return;
+            }
+            var operations = _this.graphOperationQueue;
+            _this.graphOperationQueue = [];
+            var graphOperations = operations
+                .map(function (operation) {
+                return mapOperationToGraphOperation(operation, function (op) {
+                    var value = _this.options.getFinalUserEnteredValue(op.position);
+                    return typeof value === "string" ? value : undefined;
+                }, { markDirty: false });
+            })
+                .filter(function (op) { return Boolean(op); });
+            if (!graphOperations.length) {
+                return;
+            }
+            _this.graph.applyGraphOperations(graphOperations);
+        });
+    };
+    CalculationInterface.prototype.buildWorkerMetadata = function () {
+        return this.options.getSheets().map(function (sheet) { return ({
+            id: sheet.sheetId,
+            name: sheet.title,
+        }); });
+    };
+    CalculationInterface.prototype.buildMetadataSignature = function () {
+        var sheets = this.buildWorkerMetadata();
+        var tables = this.options.getTables();
+        var namedRanges = this.options.getNamedRanges();
+        return JSON.stringify({ sheets: sheets, tables: tables, namedRanges: namedRanges });
+    };
+    CalculationInterface.prototype.ensureWorkerMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var signature;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        signature = this.buildMetadataSignature();
+                        if (!this.metadataDirty && signature === this.lastMetadataSignature) {
+                            return [2 /*return*/];
+                        }
+                        this.metadataDirty = false;
+                        this.lastMetadataSignature = signature;
+                        return [4 /*yield*/, this.workerClient.initialize({
+                                sheets: this.buildWorkerMetadata(),
+                                tables: this.options.getTables(),
+                                namedRanges: this.options.getNamedRanges(),
+                                locale: this.options.locale,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CalculationInterface.prototype.isClientOnlyFormula = function (position) {
+        var value = this.options.getFinalUserEnteredValue(position);
+        if (typeof value !== "string") {
+            return false;
+        }
+        if (!value.trim().startsWith("=")) {
+            return false;
+        }
+        if (!this.options.clientOnlyFunctionPattern) {
+            return false;
+        }
+        return this.options.clientOnlyFunctionPattern.test(value);
+    };
+    CalculationInterface.prototype.executeOperations = function (operations) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filteredOperations, results, expandedResults;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ensureWorkerMetadata()];
+                    case 1:
+                        _a.sent();
+                        filteredOperations = operations;
+                        if (!filteredOperations.length) {
+                            return [2 /*return*/, []];
+                        }
+                        return [4 /*yield*/, enqueueCalculationOperations({
+                                graph: this.graph,
+                                workerClient: this.workerClient,
+                                operations: filteredOperations,
+                                resolveFormula: function (operation) {
+                                    var value = _this.options.getFinalUserEnteredValue(operation.position);
+                                    return typeof value === "string" ? value : undefined;
+                                },
+                                onPlanBuilt: function (plan) {
+                                    if (!_this.options.onBeginCalculation)
+                                        return;
+                                    var dirtyCells = plan.nodes
+                                        .filter(function (node) { return node.kind === "cell"; })
+                                        .map(function (node) { return node.position; });
+                                    _this.options.onBeginCalculation(dirtyCells);
+                                },
+                                shouldSkipNode: function (node) { return _this.isClientOnlyFormula(node.position); },
+                                normalizePropertyOverride: function (value, property) {
+                                    if (!_this.options.getEffectiveStructuredValue) {
+                                        return undefined;
+                                    }
+                                    return _this.options.getEffectiveStructuredValue(value, property);
+                                },
+                            })];
+                    case 2:
+                        results = _a.sent();
+                        expandedResults = results.flatMap(function (result) {
+                            return expandWorkerResult(result);
+                        });
+                        if (expandedResults.length) {
+                            this.options.onResults(expandedResults);
+                        }
+                        return [2 /*return*/, expandedResults];
+                }
+            });
+        });
+    };
+    CalculationInterface.prototype.createDefaultWorker = function () {
+        if (typeof require !== "function") {
+            throw new Error("createCalculationWorker must be provided outside of Node.js.");
+        }
+        var requireFunc = require;
+        var Worker = requireFunc("node:worker_threads").Worker;
+        var workerPath = requireFunc.resolve("@rowsncolumns/calculation-worker/worker");
+        return new Worker(workerPath, { type: "module" });
+    };
+    CalculationInterface.prototype.ensureWorker = function (worker) {
+        if ("addEventListener" in worker) {
+            return worker;
+        }
+        var nodeWorker = worker;
+        var handlerMap = new Map();
+        var addEventListener = function (type, listener) {
+            var _a;
+            var handlers = (_a = handlerMap.get(type)) !== null && _a !== void 0 ? _a : new Map();
+            var handler = type === "message"
+                ? function (data) {
+                    if (typeof listener === "function") {
+                        listener({ data: data });
+                    }
+                    else {
+                        listener.handleEvent({ data: data });
+                    }
+                }
+                : function (error) {
+                    if (typeof listener === "function") {
+                        listener({ error: error });
+                    }
+                    else {
+                        listener.handleEvent({ error: error });
+                    }
+                };
+            handlers.set(listener, handler);
+            handlerMap.set(type, handlers);
+            nodeWorker.on(type, handler);
+        };
+        var removeEventListener = function (type, listener) {
+            var handlers = handlerMap.get(type);
+            var handler = handlers === null || handlers === void 0 ? void 0 : handlers.get(listener);
+            if (!handler) {
+                return;
+            }
+            nodeWorker.off(type, handler);
+            handlers === null || handlers === void 0 ? void 0 : handlers.delete(listener);
+            if (handlers && handlers.size === 0) {
+                handlerMap.delete(type);
+            }
+        };
+        nodeWorker.addEventListener = addEventListener;
+        nodeWorker.removeEventListener = removeEventListener;
+        return nodeWorker;
+    };
+    return CalculationInterface;
+}());
+export { CalculationInterface };

package/dist/cjs/interface/change-batch-stream.d.ts

@@ -0,0 +1,25 @@
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+import { type CellCoordinate } from "@rowsncolumns/dag";
+import type { CellData, ChangeBatchStreamOptions, ParsedToken, Sheet } from "@rowsncolumns/spreadsheet";
+import type { useCalculation } from "../hooks/use-calculation";
+import type { CellXfsRegistry } from "../hooks/use-cellxfs-registry";
+import type { UseOnChangeBatchProps } from "../hooks/use-on-change-batch";
+import type { ChangeBatchStreamInput } from "../types";
+export type ChangeBatchStreamAddFormulaToGraph = (formulaValue: string, position: CellCoordinate) => void;
+export type ChangeBatchStreamProps<T extends CellData, S extends Sheet = Sheet> = Pick<UseOnChangeBatchProps<T, S>, "onChangeSheetData" | "getEffectiveValuesFromRange" | "locale" | "getDataValidationById" | "enqueueCalculation"> & {
+    onChangeSheets?: UseOnChangeBatchProps<T, S>["onChangeSheets"];
+    getFormattedValue?: UseOnChangeBatchProps<T, S>["getFormattedValue"];
+    getCellDimensions?: UseOnChangeBatchProps<T, S>["getCellDimensions"];
+    getRowHeight?: UseOnChangeBatchProps<T, S>["getRowHeight"];
+    isMergedCell?: UseOnChangeBatchProps<T, S>["isMergedCell"];
+    onRequestCalculate?: ReturnType<typeof useCalculation>["onRequestCalculate"];
+    getPrecedentsFromFormulaString?: ReturnType<typeof useCalculation>["getPrecedentsFromFormulaString"];
+    getSheetId?: (sheetName: string) => number;
+    cellXfsRegistry?: CellXfsRegistry;
+    tokenizer?: (value: string) => ParsedToken[];
+    onStreamStart?: (streamId: string) => void;
+    onStreamProgress?: (streamId: string, sheetId: number, lastCellPosition: CellInterface | null) => void;
+    onStreamEnd?: (streamId: string) => void;
+};
+export declare const changeBatchStream: <T extends CellData, S extends Sheet = Sheet>({ locale, onChangeSheetData, onChangeSheets, getEffectiveValuesFromRange, getFormattedValue, getCellDimensions, getRowHeight, isMergedCell, getDataValidationById, onRequestCalculate, getPrecedentsFromFormulaString, getSheetId, cellXfsRegistry, tokenizer, onStreamStart, onStreamProgress, onStreamEnd, }: ChangeBatchStreamProps<T, S>) => (sheetId: number, range: GridRange, stream: ChangeBatchStreamInput, streamOptions?: ChangeBatchStreamOptions) => Promise<void>;
+//# sourceMappingURL=change-batch-stream.d.ts.map

package/dist/cjs/interface/change-batch-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-batch-stream.d.ts","sourceRoot":"","sources":["../../../interface/change-batch-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAAE,KAAK,cAAc,EAAW,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EACV,QAAQ,EAER,wBAAwB,EAExB,WAAW,EACX,KAAK,EACN,MAAM,2BAA2B,CAAC;AAKnC,OAAO,KAAK,EAEV,cAAc,EACf,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAE1E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,MAAM,MAAM,kCAAkC,GAAG,CAC/C,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,cAAc,KACrB,IAAI,CAAC;AAEV,MAAM,MAAM,sBAAsB,CAChC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,KAAK,GAAG,KAAK,IACrB,IAAI,CACN,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,mBAAmB,GACnB,6BAA6B,GAC7B,QAAQ,GACR,uBAAuB,GACvB,oBAAoB,CACvB,GAAG;IACF,cAAc,CAAC,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC/D,iBAAiB,CAAC,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IACrE,iBAAiB,CAAC,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IACrE,YAAY,CAAC,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;IAC3D,YAAY,CAAC,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;IAC3D,kBAAkB,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7E,8BAA8B,CAAC,EAAE,UAAU,CACzC,OAAO,cAAc,CACtB,CAAC,gCAAgC,CAAC,CAAC;IACpC,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3C,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,WAAW,EAAE,CAAC;IAC7C,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,gBAAgB,CAAC,EAAE,CACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,aAAa,GAAG,IAAI,KACnC,IAAI,CAAC;IACV,WAAW,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1C,CAAC;AAyBF,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,GAAG,KAAK,EAAE,gTAkB5E,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE3B,SAAS,MAAM,EACf,OAAO,SAAS,EAChB,QAAQ,sBAAsB,EAC9B,gBAAgB,wBAAwB,kBA4W3C,CAAC"}