@bilig/headless 0.1.102 → 0.2.0

package/dist/work-paper-runtime.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();
@@ -1884,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);
@@ -1895,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])
@@ -1908,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);
@@ -1919,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])
@@ -1946,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, () => {
@@ -1958,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, () => {
@@ -2500,44 +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,
         };
     }
-    materializeTrackedEventChanges(event) {
-        if (event.patches && event.patches.length > 0) {
-            const cellPatches = event.patches.filter((patch) => patch.kind === 'cell');
-            return cellPatches;
-        }
-        const changes = [];
-        for (let index = 0; index < event.changedCellIndices.length; index += 1) {
-            const change = this.readTrackedCellChange(event.changedCellIndices[index]);
-            if (change) {
-                changes.push(change);
-            }
-        }
-        return changes;
-    }
-    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) {
@@ -2554,68 +2620,96 @@ export class WorkPaper {
         };
         if (events.length === 1) {
             const event = events[0];
-            const eventChanges = this.materializeTrackedEventChanges(event);
-            let hasDuplicateCellKey = false;
-            if (eventChanges.length <= 4) {
-                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);
-                    for (let priorIndex = 0; priorIndex < index; priorIndex += 1) {
-                        const prior = eventChanges[priorIndex];
-                        if (makeCellKey(prior.address.sheet, prior.address.row, prior.address.col) === cellKey) {
-                            hasDuplicateCellKey = true;
-                            break;
+            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);
+                        }
+                        else {
+                            sheet.cells.set(cellKey, change.newValue);
                         }
                     }
-                    if (hasDuplicateCellKey) {
-                        break;
-                    }
+                    return { changes: [change], nextVisibility };
                 }
             }
-            else {
-                const seenCellKeys = new Set();
-                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);
+            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 < eventChanges.length; index += 1) {
-                    const change = eventChanges[index];
-                    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;
+                else if (smallCellKeys) {
+                    for (let priorIndex = 0; priorIndex < index; priorIndex += 1) {
+                        if (smallCellKeys[priorIndex] === cellKey) {
+                            hasDuplicateCellKey = true;
+                            break;
+                        }
                     }
+                    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
@@ -2626,7 +2720,7 @@ export class WorkPaper {
         }
         const latestChangesByKey = new Map();
         for (const event of events) {
-            const eventChanges = this.materializeTrackedEventChanges(event);
+            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);
@@ -2640,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()];
@@ -2691,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');
         }