@bilig/headless 0.1.101 → 0.2.0

package/dist/work-paper-runtime.js

@@ -1,4 +1,4 @@
-import { SpreadsheetEngine, makeCellKey } from '@bilig/core';
+import { SpreadsheetEngine, attachRuntimeSnapshot, makeCellKey, readRuntimeSnapshot, } from '@bilig/core';
 import { ErrorCode, MAX_COLS, MAX_ROWS, ValueTag, } from '@bilig/protocol';
 import { excelSerialToDateParts, formatAddress, formatRangeAddress, installExternalFunctionAdapter, isArrayValue, isCellReferenceText, parseCellAddress, parseFormula, parseRangeAddress, serializeFormula, translateFormulaReferences, } from '@bilig/formula';
 import { loadInitialMixedSheet, tryLoadInitialLiteralSheet } from './initial-sheet-load.js';
@@ -6,6 +6,7 @@ import { orderWorkPaperCellChanges } from './change-order.js';
 import { WorkPaperConfigValueTooBigError, WorkPaperConfigValueTooSmallError, WorkPaperEvaluationSuspendedError, WorkPaperExpectedValueOfTypeError, WorkPaperOperationError, WorkPaperParseError, WorkPaperSheetError, WorkPaperExpectedOneOfValuesError, WorkPaperFunctionPluginValidationError, WorkPaperInvalidArgumentsError, WorkPaperLanguageAlreadyRegisteredError, WorkPaperLanguageNotRegisteredError, WorkPaperNamedExpressionDoesNotExistError, WorkPaperNamedExpressionNameIsAlreadyTakenError, WorkPaperNamedExpressionNameIsInvalidError, WorkPaperNoOperationToRedoError, WorkPaperNoOperationToUndoError, WorkPaperNoRelativeAddressesAllowedError, WorkPaperNoSheetWithIdError, WorkPaperNoSheetWithNameError, WorkPaperNotAFormulaError, WorkPaperNothingToPasteError, WorkPaperSheetNameAlreadyTakenError, WorkPaperSheetSizeLimitExceededError, WorkPaperUnableToParseError, } from './work-paper-errors.js';
 import { buildMatrixMutationPlan } from './matrix-mutation-plan.js';
 import { captureTrackedEngineEvent } from './tracked-engine-event-refs.js';
+import { materializeTrackedIndexChangesWithMetadata } from './tracked-cell-index-changes.js';
 import { calculateWorkPaperFormulaInScratchWorkbook } from './work-paper-scratch-evaluator.js';
 import { replaceWorkPaperSheetContent } from './work-paper-sheet-replacement.js';
 const EMPTY_NAMED_EXPRESSION_VALUES = new Map();
@@ -810,10 +811,18 @@ export class WorkPaper {
     }
     static buildFromSheets(sheets, configInput = {}, namedExpressions = []) {
         const workbook = new WorkPaper(configInput);
+        const runtimeSnapshot = namedExpressions.length === 0 ? readRuntimeSnapshot(sheets) : undefined;
+        const runtimeSnapshotMatchesSheets = runtimeSnapshot !== undefined &&
+            runtimeSnapshot.sheets.length === Object.keys(sheets).length &&
+            runtimeSnapshot.sheets.every((sheet) => Object.prototype.hasOwnProperty.call(sheets, sheet.name));
         Object.entries(sheets).forEach(([sheetName, sheet]) => {
             validateSheetWithinLimits(sheetName, sheet, workbook.config);
         });
         workbook.withEngineEventCaptureDisabled(() => {
+            if (runtimeSnapshot && runtimeSnapshotMatchesSheets) {
+                workbook.engine.importSnapshot(runtimeSnapshot);
+                return;
+            }
             Object.keys(sheets).forEach((sheetName) => {
                 workbook.engine.createSheet(sheetName);
             });
@@ -1023,6 +1032,16 @@ export class WorkPaper {
             lastMetrics: structuredClone(this.engine.getLastMetrics()),
         };
     }
+    getPerformanceCounters() {
+        this.assertNotDisposed();
+        const counterAwareEngine = this.engine;
+        return structuredClone(counterAwareEngine.getPerformanceCounters());
+    }
+    resetPerformanceCounters() {
+        this.assertNotDisposed();
+        const counterAwareEngine = this.engine;
+        counterAwareEngine.resetPerformanceCounters();
+    }
     rebuildAndRecalculate() {
         this.assertNotDisposed();
         if (this.shouldSuppressEvents()) {
@@ -1312,7 +1331,9 @@ export class WorkPaper {
         return Object.fromEntries(this.listSheetRecords().map((sheet) => [sheet.name, this.getSheetFormulas(sheet.id)]));
     }
     getAllSheetsSerialized() {
-        return Object.fromEntries(this.listSheetRecords().map((sheet) => [sheet.name, this.getSheetSerialized(sheet.id)]));
+        const serialized = Object.fromEntries(this.listSheetRecords().map((sheet) => [sheet.name, this.getSheetSerialized(sheet.id)]));
+        attachRuntimeSnapshot(serialized, this.engine.exportSnapshot());
+        return serialized;
     }
     getAllSheetsDimensions() {
         return Object.fromEntries(this.listSheetRecords().map((sheet) => [sheet.name, this.getSheetDimensions(sheet.id)]));
@@ -1864,6 +1885,12 @@ export class WorkPaper {
         if (!this.isItPossibleToAddRows(sheetId, ...indexes)) {
             throw new WorkPaperOperationError('Rows cannot be added');
         }
+        if (indexes.length === 1 && this.canUseTrackedStructuralFastPath()) {
+            const [start, amount] = indexes[0];
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                this.engine.insertRows(this.sheetName(sheetId), start, amount);
+            });
+        }
         return this.batchStructuralChanges(() => {
             indexes.forEach(([start, amount]) => {
                 this.engine.insertRows(this.sheetName(sheetId), start, amount);
@@ -1875,6 +1902,12 @@ export class WorkPaper {
         if (!this.isItPossibleToRemoveRows(sheetId, ...indexes)) {
             throw new WorkPaperOperationError('Rows cannot be removed');
         }
+        if (indexes.length === 1 && this.canUseTrackedStructuralFastPath()) {
+            const [start, amount] = indexes[0];
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                this.engine.deleteRows(this.sheetName(sheetId), start, amount);
+            });
+        }
         return this.batchStructuralChanges(() => {
             indexes
                 .toSorted((left, right) => right[0] - left[0])
@@ -1888,6 +1921,12 @@ export class WorkPaper {
         if (!this.isItPossibleToAddColumns(sheetId, ...indexes)) {
             throw new WorkPaperOperationError('Columns cannot be added');
         }
+        if (indexes.length === 1 && this.canUseTrackedStructuralFastPath()) {
+            const [start, amount] = indexes[0];
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                this.engine.insertColumns(this.sheetName(sheetId), start, amount);
+            });
+        }
         return this.batchStructuralChanges(() => {
             indexes.forEach(([start, amount]) => {
                 this.engine.insertColumns(this.sheetName(sheetId), start, amount);
@@ -1899,6 +1938,12 @@ export class WorkPaper {
         if (!this.isItPossibleToRemoveColumns(sheetId, ...indexes)) {
             throw new WorkPaperOperationError('Columns cannot be removed');
         }
+        if (indexes.length === 1 && this.canUseTrackedStructuralFastPath()) {
+            const [start, amount] = indexes[0];
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                this.engine.deleteColumns(this.sheetName(sheetId), start, amount);
+            });
+        }
         return this.batchStructuralChanges(() => {
             indexes
                 .toSorted((left, right) => right[0] - left[0])
@@ -1926,7 +1971,7 @@ export class WorkPaper {
             throw new WorkPaperOperationError('Rows cannot be moved');
         }
         return this.canUseTrackedStructuralFastPath()
-            ? this.batchStructuralChanges(() => {
+            ? this.captureTrackedChangesWithoutVisibilityCache(() => {
                 this.engine.moveRows(this.sheetName(sheetId), start, count, target);
             })
             : this.captureChanges(undefined, () => {
@@ -1938,7 +1983,7 @@ export class WorkPaper {
             throw new WorkPaperOperationError('Columns cannot be moved');
         }
         return this.canUseTrackedStructuralFastPath()
-            ? this.batchStructuralChanges(() => {
+            ? this.captureTrackedChangesWithoutVisibilityCache(() => {
                 this.engine.moveColumns(this.sheetName(sheetId), start, count, target);
             })
             : this.captureChanges(undefined, () => {
@@ -2480,30 +2525,85 @@ export class WorkPaper {
         });
         return orderWorkPaperCellChanges(cellChanges, this.listSheetRecords());
     }
-    readTrackedCellChange(cellIndex) {
-        const sheetId = this.engine.workbook.cellStore.sheetIds[cellIndex];
-        const row = this.engine.workbook.cellStore.rows[cellIndex];
-        const col = this.engine.workbook.cellStore.cols[cellIndex];
-        if (sheetId === undefined || row === undefined || col === undefined) {
-            return undefined;
+    materializeTrackedEventChanges(event) {
+        if (event.patches && event.patches.length > 0) {
+            const cellPatches = event.patches.filter((patch) => patch.kind === 'cell');
+            return { changes: cellPatches, canReusePublicChanges: false, ordered: false };
         }
-        const sheetName = this.engine.workbook.getSheetNameById(sheetId);
-        if (sheetName === undefined) {
+        const materialized = materializeTrackedIndexChangesWithMetadata(this.engine, event.changedCellIndices, {
+            explicitChangedCount: event.explicitChangedCount,
+        });
+        return {
+            changes: materialized.changes,
+            canReusePublicChanges: true,
+            ordered: materialized.ordered,
+        };
+    }
+    readSingleTrackedCellChange(cellIndex) {
+        const cellStore = this.engine.workbook.cellStore;
+        const sheetId = cellStore.sheetIds[cellIndex];
+        if (sheetId === undefined) {
             return undefined;
         }
+        const sheet = this.engine.workbook.getSheetById(sheetId);
+        const sheetName = sheet?.name ?? this.engine.workbook.getSheetNameById(sheetId);
+        let row;
+        let col;
+        if (!sheet || sheet.structureVersion === 1) {
+            row = cellStore.rows[cellIndex];
+            col = cellStore.cols[cellIndex];
+        }
+        else {
+            const position = this.engine.workbook.getCellPosition(cellIndex);
+            if (!position) {
+                return undefined;
+            }
+            row = position.row;
+            col = position.col;
+        }
+        const tag = cellStore.tags[cellIndex] ?? ValueTag.Empty;
+        let newValue;
+        switch (tag) {
+            case ValueTag.Number:
+                newValue = { tag: ValueTag.Number, value: cellStore.numbers[cellIndex] ?? 0 };
+                break;
+            case ValueTag.Boolean:
+                newValue = { tag: ValueTag.Boolean, value: (cellStore.numbers[cellIndex] ?? 0) !== 0 };
+                break;
+            case ValueTag.String:
+                newValue = cellStore.getValue(cellIndex, (stringId) => this.engine.strings.get(stringId));
+                break;
+            case ValueTag.Error:
+                newValue = { tag: ValueTag.Error, code: cellStore.errors[cellIndex] };
+                break;
+            case ValueTag.Empty:
+            default:
+                newValue = { tag: ValueTag.Empty };
+                break;
+        }
         return {
             kind: 'cell',
             address: { sheet: sheetId, row, col },
             sheetName,
             a1: formatAddress(row, col),
-            newValue: this.engine.workbook.cellStore.getValue(cellIndex, (id) => this.engine.strings.get(id)),
+            newValue,
         };
     }
-    computeCellChangesFromTrackedEvents(beforeVisibility, events) {
+    computeCellChangesFromTrackedEvents(beforeVisibility, events, updateVisibility = true) {
         if (events.some((event) => event.invalidation === 'full')) {
             return null;
         }
         const nextVisibility = beforeVisibility;
+        const sheetOrders = new Map();
+        const sheetOrderFor = (sheetId) => {
+            const existing = sheetOrders.get(sheetId);
+            if (existing !== undefined) {
+                return existing;
+            }
+            const order = this.sheetRecord(sheetId).order;
+            sheetOrders.set(sheetId, order);
+            return order;
+        };
         const ensureMutableSheet = (sheetId, sheetName) => {
             const existing = nextVisibility.get(sheetId);
             if (existing) {
@@ -2520,79 +2620,96 @@ export class WorkPaper {
         };
         if (events.length === 1) {
             const event = events[0];
-            let hasDuplicateCellKey = false;
-            if (event.changedCellIndices.length <= 4) {
-                for (let index = 0; index < event.changedCellIndices.length; index += 1) {
-                    const change = this.readTrackedCellChange(event.changedCellIndices[index]);
-                    if (!change) {
-                        continue;
-                    }
-                    const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
-                    for (let priorIndex = 0; priorIndex < index; priorIndex += 1) {
-                        const prior = this.readTrackedCellChange(event.changedCellIndices[priorIndex]);
-                        if (!prior) {
-                            continue;
+            if (event.invalidation !== 'full' &&
+                event.patches === undefined &&
+                event.changedCellIndices.length === 1 &&
+                event.explicitChangedCount === 1 &&
+                event.changedInputCount === 1 &&
+                !event.hasInvalidatedRanges &&
+                !event.hasInvalidatedRows &&
+                !event.hasInvalidatedColumns) {
+                const change = this.readSingleTrackedCellChange(event.changedCellIndices[0]);
+                if (change) {
+                    if (updateVisibility) {
+                        const sheet = ensureMutableSheet(change.address.sheet, change.sheetName);
+                        const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+                        if (change.newValue.tag === ValueTag.Empty) {
+                            sheet.cells.delete(cellKey);
                         }
-                        if (makeCellKey(prior.address.sheet, prior.address.row, prior.address.col) === cellKey) {
-                            hasDuplicateCellKey = true;
-                            break;
+                        else {
+                            sheet.cells.set(cellKey, change.newValue);
                         }
                     }
-                    if (hasDuplicateCellKey) {
-                        break;
-                    }
+                    return { changes: [change], nextVisibility };
                 }
             }
-            else {
-                const seenCellKeys = new Set();
-                for (let index = 0; index < event.changedCellIndices.length; index += 1) {
-                    const change = this.readTrackedCellChange(event.changedCellIndices[index]);
-                    if (!change) {
-                        continue;
-                    }
-                    const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+            const materializedEventChanges = this.materializeTrackedEventChanges(event);
+            const eventChanges = materializedEventChanges.changes;
+            if (!updateVisibility && materializedEventChanges.canReusePublicChanges && materializedEventChanges.ordered) {
+                return {
+                    changes: [...eventChanges],
+                    nextVisibility,
+                };
+            }
+            const directChanges = [];
+            const seenCellKeys = eventChanges.length > 4 && eventChanges.length <= 64 ? new Set() : undefined;
+            const smallCellKeys = eventChanges.length > 1 && eventChanges.length <= 4 ? [] : undefined;
+            let hasDuplicateCellKey = false;
+            let alreadySorted = true;
+            let previousSheetOrder = -1;
+            let previousRow = -1;
+            let previousCol = -1;
+            for (let index = 0; index < eventChanges.length; index += 1) {
+                const change = eventChanges[index];
+                const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+                if (seenCellKeys) {
                     if (seenCellKeys.has(cellKey)) {
                         hasDuplicateCellKey = true;
                         break;
                     }
                     seenCellKeys.add(cellKey);
                 }
-            }
-            if (!hasDuplicateCellKey) {
-                const directChanges = [];
-                let alreadySorted = true;
-                let previousSheetOrder = -1;
-                let previousRow = -1;
-                let previousCol = -1;
-                for (let index = 0; index < event.changedCellIndices.length; index += 1) {
-                    const change = this.readTrackedCellChange(event.changedCellIndices[index]);
-                    if (!change) {
-                        continue;
+                else if (smallCellKeys) {
+                    for (let priorIndex = 0; priorIndex < index; priorIndex += 1) {
+                        if (smallCellKeys[priorIndex] === cellKey) {
+                            hasDuplicateCellKey = true;
+                            break;
+                        }
                     }
-                    const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
-                    const sheet = ensureMutableSheet(change.address.sheet, change.sheetName);
-                    if (sheet.order < previousSheetOrder ||
-                        (sheet.order === previousSheetOrder &&
-                            (change.address.row < previousRow || (change.address.row === previousRow && change.address.col < previousCol)))) {
-                        alreadySorted = false;
+                    if (hasDuplicateCellKey) {
+                        break;
                     }
+                    smallCellKeys[index] = cellKey;
+                }
+                const sheet = updateVisibility ? ensureMutableSheet(change.address.sheet, change.sheetName) : undefined;
+                const sheetOrder = sheet?.order ?? sheetOrderFor(change.address.sheet);
+                if (sheetOrder < previousSheetOrder ||
+                    (sheetOrder === previousSheetOrder &&
+                        (change.address.row < previousRow || (change.address.row === previousRow && change.address.col < previousCol)))) {
+                    alreadySorted = false;
+                }
+                if (sheet) {
                     if (change.newValue.tag === ValueTag.Empty) {
                         sheet.cells.delete(cellKey);
                     }
                     else {
                         sheet.cells.set(cellKey, change.newValue);
                     }
-                    directChanges[index] = {
+                }
+                directChanges[index] = materializedEventChanges.canReusePublicChanges
+                    ? change
+                    : {
                         kind: 'cell',
                         address: change.address,
                         sheetName: change.sheetName,
                         a1: change.a1,
                         newValue: change.newValue,
                     };
-                    previousSheetOrder = sheet.order;
-                    previousRow = change.address.row;
-                    previousCol = change.address.col;
-                }
+                previousSheetOrder = sheetOrder;
+                previousRow = change.address.row;
+                previousCol = change.address.col;
+            }
+            if (!hasDuplicateCellKey) {
                 return {
                     changes: alreadySorted
                         ? directChanges
@@ -2603,11 +2720,9 @@ export class WorkPaper {
         }
         const latestChangesByKey = new Map();
         for (const event of events) {
-            for (let index = 0; index < event.changedCellIndices.length; index += 1) {
-                const change = this.readTrackedCellChange(event.changedCellIndices[index]);
-                if (!change) {
-                    continue;
-                }
+            const eventChanges = this.materializeTrackedEventChanges(event).changes;
+            for (let index = 0; index < eventChanges.length; index += 1) {
+                const change = eventChanges[index];
                 const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
                 latestChangesByKey.delete(cellKey);
                 latestChangesByKey.set(cellKey, {
@@ -2619,14 +2734,16 @@ export class WorkPaper {
                 });
             }
         }
-        for (const change of latestChangesByKey.values()) {
-            const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
-            const sheet = ensureMutableSheet(change.address.sheet, change.sheetName);
-            if (change.newValue.tag === ValueTag.Empty) {
-                sheet.cells.delete(cellKey);
-            }
-            else {
-                sheet.cells.set(cellKey, change.newValue);
+        if (updateVisibility) {
+            for (const change of latestChangesByKey.values()) {
+                const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+                const sheet = ensureMutableSheet(change.address.sheet, change.sheetName);
+                if (change.newValue.tag === ValueTag.Empty) {
+                    sheet.cells.delete(cellKey);
+                }
+                else {
+                    sheet.cells.set(cellKey, change.newValue);
+                }
             }
         }
         const directChanges = [...latestChangesByKey.values()];
@@ -2670,7 +2787,7 @@ export class WorkPaper {
         this.batchUsesTrackedFastPath = false;
     }
     computeTrackedChangesWithoutVisibilityCache(events) {
-        const fastPath = this.computeCellChangesFromTrackedEvents(new Map(), events);
+        const fastPath = this.computeCellChangesFromTrackedEvents(new Map(), events, false);
         if (!fastPath) {
             throw new WorkPaperOperationError('Mutation emitted an unsupported invalidation pattern for tracked changes');
         }
@@ -2828,15 +2945,69 @@ export class WorkPaper {
                 return record.ops;
             case 'single-op':
                 return [record.op];
+            case 'cell-mutations':
+                return record.refs.flatMap((ref) => {
+                    const sheetName = this.getSheetName(ref.sheetId);
+                    if (!sheetName) {
+                        return [];
+                    }
+                    const address = formatAddress(ref.mutation.row, ref.mutation.col);
+                    switch (ref.mutation.kind) {
+                        case 'setCellValue':
+                            return [
+                                {
+                                    kind: 'setCellValue',
+                                    sheetName,
+                                    address,
+                                    value: ref.mutation.value,
+                                },
+                            ];
+                        case 'setCellFormula':
+                            return [
+                                {
+                                    kind: 'setCellFormula',
+                                    sheetName,
+                                    address,
+                                    formula: ref.mutation.formula,
+                                },
+                            ];
+                        case 'clearCell':
+                            return [
+                                {
+                                    kind: 'clearCell',
+                                    sheetName,
+                                    address,
+                                },
+                            ];
+                    }
+                });
         }
     }
+    tryMergeTypedCellMutationHistory(entries) {
+        if (entries.length === 0 ||
+            entries.some((entry) => entry.forward.kind !== 'cell-mutations' || entry.inverse.kind !== 'cell-mutations')) {
+            return null;
+        }
+        return {
+            forward: {
+                kind: 'cell-mutations',
+                refs: entries.flatMap((entry) => (entry.forward.kind === 'cell-mutations' ? entry.forward.refs : [])),
+                potentialNewCells: sumNumbers(entries.map((entry) => entry.forward.potentialNewCells)),
+            },
+            inverse: {
+                kind: 'cell-mutations',
+                refs: entries.toReversed().flatMap((entry) => (entry.inverse.kind === 'cell-mutations' ? entry.inverse.refs : [])),
+                potentialNewCells: sumNumbers(entries.map((entry) => entry.inverse.potentialNewCells)),
+            },
+        };
+    }
     mergeUndoHistory(startIndex) {
         const undoStack = this.getUndoStack();
         if (undoStack.length - startIndex <= 1) {
             return;
         }
         const entries = undoStack.splice(startIndex);
-        const merged = {
+        const merged = this.tryMergeTypedCellMutationHistory(entries) ?? {
             forward: {
                 kind: 'ops',
                 ops: entries.flatMap((entry) => this.historyTransactionOps(entry.forward)),