@rowsncolumns/spreadsheet-state 28.0.76 → 29.1.0

package/dist/cjs/api/structural-table-refs.js

@@ -1,13 +1,14 @@
-import { __assign, __read, __values } from "tslib";
+import { __assign, __read, __rest, __values } from "tslib";
 import { isCellNode } from "@rowsncolumns/dag";
 import { addressToCell, getCellUserEnteredValue, getExtendedValueFormula, } from "@rowsncolumns/utils";
 import { SheetCell } from "../sheet-cell";
-import { breakTableColumnsInFormula, breakTableReferencesInFormula, createSheetCellIdentifier, } from "./formula";
+import { breakTableColumnsInFormula, breakTableReferencesInFormula, convertStructuredRefsToA1InFormula, createSheetCellIdentifier, renameTableColumnsInFormula, renameTableInFormula, } from "./formula";
 import { createSheetDraft } from "./immer-utils";
 /**
- * Which tables / table columns `deleteRow` (a table goes with its header row)
- * or `deleteColumn` (a table goes when every column is deleted; otherwise the
- * covered columns are spliced out) removes for the band
+ * Which tables / table columns `deleteRow` (a table goes only when every one
+ * of its rows is deleted — losing its header row keeps it, the next row
+ * becomes the header) or `deleteColumn` (a table goes when every column is
+ * deleted; otherwise the covered columns are spliced out) removes for the band
  * `[minIndex, maxIndex]` on `sheetId`. Mirrors the table updates those
  * interfaces apply to `tables`.
  */
@@ -21,13 +22,13 @@ export var collectRemovedTableParts = function (tables, sheetId, axis, minIndex,
             if (table.sheetId !== sheetId || !table.title)
                 continue;
             if (axis === "row") {
-                var startRowIndex = table.range.startRowIndex;
-                if (startRowIndex >= minIndex && startRowIndex <= maxIndex) {
+                var _f = table.range, startRowIndex = _f.startRowIndex, endRowIndex = _f.endRowIndex;
+                if (minIndex <= startRowIndex && maxIndex >= endRowIndex) {
                     removed.tables.push(table.title);
                 }
                 continue;
             }
-            var _f = table.range, startColumnIndex = _f.startColumnIndex, endColumnIndex = _f.endColumnIndex;
+            var _g = table.range, startColumnIndex = _g.startColumnIndex, endColumnIndex = _g.endColumnIndex;
             if (maxIndex < startColumnIndex || minIndex > endColumnIndex)
                 continue;
             if (minIndex <= startColumnIndex && maxIndex >= endColumnIndex) {
@@ -157,8 +158,168 @@ export var breakStructuredRefsForRemovedTableParts = function (_a) {
         finally { if (e_2) throw e_2.error; }
     }
 };
+/**
+ * Apply `rewrite` to the text of every formula cell across all sheets (from
+ * the dependency graph when available, else a draft sweep), writing back the
+ * ones it changed and re-entering them in the graph for recalculation. Cells
+ * keep their position — this is the in-place rewrite behind a table / table
+ * column rename.
+ */
+var rewriteFormulasInDraft = function (_a, rewrite) {
+    var e_5, _b;
+    var _c, _d;
+    var draft = _a.draft, getGraphNodes = _a.getGraphNodes, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, recalcCells = _a.recalcCells, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
+    var sheetCell = new SheetCell();
+    try {
+        for (var _e = __values(collectFormulaPositions(draft, getGraphNodes)), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var pos = _f.value;
+            var currentSheet = createSheetDraft(draft, pos.sheetId, pos.rowIndex);
+            var cellData = (_d = (_c = currentSheet[pos.rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[pos.columnIndex];
+            var formula = getExtendedValueFormula(getCellUserEnteredValue(cellData));
+            if (!formula || !formula.includes("["))
+                continue;
+            var updated = rewrite(formula, pos);
+            if (updated === formula)
+                continue;
+            sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, sharedStringRegistry: sharedStringRegistry });
+            sheetCell.setFormulaValue(updated, false);
+            currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                sheetCell.getCellData();
+            var enqueueOperation = sheetCell.ephemeral()
+                ? enqueueCalculation
+                : enqueueGraphOperation;
+            enqueueOperation === null || enqueueOperation === void 0 ? void 0 : enqueueOperation({ type: "remove", position: pos });
+            enqueueOperation === null || enqueueOperation === void 0 ? void 0 : enqueueOperation({ type: "add", position: pos, force: true });
+            recalcCells.set(createSheetCellIdentifier(pos.sheetId, pos.rowIndex, pos.columnIndex), __assign(__assign({}, pos), { force: true }));
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+};
+/**
+ * Column `oldName` of `table` was renamed `newName` (a header-cell edit):
+ * rewrite every structured reference to it across the workbook, including the
+ * bare `[@Old]` forms of the formulas that sit inside the table.
+ */
+export var renameTableColumnInFormulas = function (_a) {
+    var table = _a.table, oldName = _a.oldName, newName = _a.newName, params = __rest(_a, ["table", "oldName", "newName"]);
+    if (!oldName || !newName || oldName === newName)
+        return;
+    renameTableColumnsInFormulas(__assign(__assign({}, params), { table: table, renames: new Map([[oldName.toLowerCase(), newName]]) }));
+};
+/**
+ * Several columns of `table` were renamed at once (a header row re-derived
+ * after a row delete, several header cells written by one paste /
+ * change-batch): `renames` maps each LOWER-CASED old name to its new name and
+ * every formula is rewritten in ONE pass, so `Name` → `Qty` and `Qty` → `Name`
+ * swap instead of chaining into the same column.
+ */
+export var renameTableColumnsInFormulas = function (_a) {
+    var table = _a.table, renames = _a.renames, params = __rest(_a, ["table", "renames"]);
+    if (renames.size === 0)
+        return;
+    rewriteFormulasInDraft(params, function (formula, pos) {
+        var updated = table.title
+            ? renameTableColumnsInFormula(formula, table.title, renames)
+            : formula;
+        if (pos.sheetId === table.sheetId &&
+            isWithinRange(table.range, pos.rowIndex, pos.columnIndex)) {
+            updated = renameTableColumnsInFormula(updated, undefined, renames);
+        }
+        return updated;
+    });
+};
+/**
+ * The header cells one write renamed (`planHeaderCellRenames`), applied per
+ * table as a single multi-column rename.
+ */
+export var renameHeaderCellsInFormulas = function (_a) {
+    var e_6, _b, e_7, _c;
+    var _d;
+    var headerRenames = _a.headerRenames, params = __rest(_a, ["headerRenames"]);
+    var byTable = new Map();
+    try {
+        for (var headerRenames_1 = __values(headerRenames), headerRenames_1_1 = headerRenames_1.next(); !headerRenames_1_1.done; headerRenames_1_1 = headerRenames_1.next()) {
+            var _e = headerRenames_1_1.value, table = _e.table, oldName = _e.oldName, newName = _e.newName;
+            if (!oldName || oldName === newName)
+                continue;
+            var entry = (_d = byTable.get(table.id)) !== null && _d !== void 0 ? _d : { table: table, renames: new Map() };
+            entry.renames.set(oldName.toLowerCase(), newName);
+            byTable.set(table.id, entry);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (headerRenames_1_1 && !headerRenames_1_1.done && (_b = headerRenames_1.return)) _b.call(headerRenames_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    try {
+        for (var _f = __values(byTable.values()), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var _h = _g.value, table = _h.table, renames = _h.renames;
+            renameTableColumnsInFormulas(__assign(__assign({}, params), { table: table, renames: renames }));
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+};
+/**
+ * `table` is being converted to a range (Excel's Convert to Range): rewrite
+ * every structured reference into it across the workbook to the A1 reference
+ * it resolves to — `T[Col]` → `$B$2:$B$9`, `[@Col]` → `B3`,
+ * `T[[#Headers],[Col]]` → `$B$1`, qualified with the table's sheet from another
+ * sheet — so the formulas keep their values once the table is gone. Runs
+ * BEFORE the table is removed; the bare `[@Col]` forms belong to the formulas
+ * that sit inside the table.
+ */
+export var convertTableReferencesToA1InFormulas = function (_a) {
+    var _b;
+    var table = _a.table, getSheetName = _a.getSheetName, params = __rest(_a, ["table", "getSheetName"]);
+    if (!table.title)
+        return;
+    var target = {
+        title: table.title,
+        range: table.range,
+        headerRow: table.headerRow,
+        totalRow: table.totalRow,
+        columnNames: ((_b = table.columns) !== null && _b !== void 0 ? _b : []).map(function (column) { return column.name; }),
+    };
+    var tableSheetName = getSheetName(table.sheetId);
+    rewriteFormulasInDraft(params, function (formula, pos) {
+        return convertStructuredRefsToA1InFormula(formula, target, {
+            tableSheetName: tableSheetName,
+            formulaSheetName: getSheetName(pos.sheetId),
+            formulaRowIndex: pos.rowIndex,
+            inTable: pos.sheetId === table.sheetId &&
+                isWithinRange(table.range, pos.rowIndex, pos.columnIndex),
+        });
+    });
+};
+/**
+ * Table `oldName` was renamed `newName` (the Edit Table dialog / `updateTable`):
+ * rewrite `Old[…]` → `New[…]` in every formula across the workbook.
+ */
+export var renameTableInFormulas = function (_a) {
+    var oldName = _a.oldName, newName = _a.newName, params = __rest(_a, ["oldName", "newName"]);
+    if (!oldName || !newName || oldName === newName)
+        return;
+    rewriteFormulasInDraft(params, function (formula) {
+        return renameTableInFormula(formula, oldName, newName);
+    });
+};
 var collectFormulaPositions = function (draft, getGraphNodes) {
-    var e_5, _a, e_6, _b;
+    var e_8, _a, e_9, _b;
     if (getGraphNodes) {
         var graphNodes = void 0;
         try {
@@ -179,12 +340,12 @@ var collectFormulaPositions = function (draft, getGraphNodes) {
                     positions_1.push(__assign({}, node.position));
                 }
             }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
             finally {
                 try {
                     if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
                 }
-                finally { if (e_5) throw e_5.error; }
+                finally { if (e_8) throw e_8.error; }
             }
             if (sawNode)
                 return positions_1;
@@ -212,17 +373,17 @@ var collectFormulaPositions = function (draft, getGraphNodes) {
             _loop_1(key);
         }
     }
-    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
     finally {
         try {
             if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
         }
-        finally { if (e_6) throw e_6.error; }
+        finally { if (e_9) throw e_9.error; }
     }
     return positions;
 };
 export var removeSpillsOfDeletedAnchors = function (_a) {
-    var e_7, _b;
+    var e_10, _b;
     var _c, _d, _e;
     var draft = _a.draft, sheetId = _a.sheetId, axis = _a.axis, minIndex = _a.minIndex, maxIndex = _a.maxIndex, getArrayRange = _a.getArrayRange, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
     var sheetRows = draft[sheetId];
@@ -287,12 +448,12 @@ export var removeSpillsOfDeletedAnchors = function (_a) {
             }
         }
     }
-    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
     finally {
         try {
             if (anchors_1_1 && !anchors_1_1.done && (_b = anchors_1.return)) _b.call(anchors_1);
         }
-        finally { if (e_7) throw e_7.error; }
+        finally { if (e_10) throw e_10.error; }
     }
 };
 /** `C1:C3` (the anchor's persisted `af`) → its rectangle; `undefined` when absent/unparseable. */

package/dist/cjs/api/subtotal.d.ts

@@ -30,22 +30,29 @@ export type SubtotalWrite = {
     values: (string | null)[];
 };
 /**
- * The plan applies in this order, every index already in FINAL coordinates
- * (the sheet after all removals and insertions):
+ * The plan applies in this order:
  *   1. `deleteRows` (descending original indexes — existing subtotal rows),
- *   2. `insertRows` ascending: inserting at final row `r` shifts the not-yet
+ *   2. `ungroupRows`: one `ungroup-rows` call per entry — the outline reset of
+ *      "Replace current subtotals" — in the coordinates of the sheet AFTER the
+ *      deletes and BEFORE the inserts (the surviving data rows, compacted).
+ *      Group / ungroup are ±1 steps in both engines, so pass `k` lists the
+ *      surviving data rows that were deeper than level `k`; after the passes
+ *      every surviving row is back at level 0 (empty when nothing was outlined
+ *      or when not replacing). The reset has to precede the inserts: an
+ *      inserted row takes the row above's outline level in both engines
+ *      (Excel's "Format Same As Above" — a row inserted inside a group joins
+ *      it), so the total rows must be inserted next to level-0 rows — Excel's
+ *      own order: remove the subtotals, rows and outline, then apply afresh.
+ *   3. `insertRows` ascending, in FINAL coordinates (the sheet after all
+ *      removals and insertions): inserting at final row `r` shifts the not-yet
  *      final rows below it, so ascending order lands each new row exactly
  *      where the plan expects it,
- *   3. `writes` (labels + SUBTOTAL formulas),
- *   4. `ungroupRows`: one `ungroup-rows` call per entry — the outline reset of
- *      "Replace current subtotals". Group / ungroup are ±1 steps in both
- *      engines, so pass `k` lists the surviving data rows that were deeper
- *      than level `k`; after the passes every row of the range is back at
- *      level 0 (empty when nothing was outlined or when not replacing), then
- *   5. `outlineGroups`: one `group-rows` call per entry (Excel's levels — the
- *      first spans every row above the grand total, the second the detail
- *      rows of each group, so detail rows end at level 2 and subtotal rows
- *      at level 1 — the same three-level outline on every re-apply).
+ *   4. `writes` (labels + SUBTOTAL formulas), final coordinates, then
+ *   5. `outlineGroups`: one `group-rows` call per entry, final coordinates
+ *      (Excel's levels — the first spans every row above the grand total, the
+ *      second the detail rows of each group, so detail rows end at level 2 and
+ *      subtotal rows at level 1 — the same three-level outline on every
+ *      re-apply).
  */
 export type SubtotalPlan = {
     deleteRows: number[];

package/dist/cjs/api/subtotal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subtotal.d.ts","sourceRoot":"","sources":["../../../api/subtotal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EACL,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAC9B,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAYtE,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,0BAA0B,gBAAgB,CAAC;AACxD,eAAO,MAAM,kBAAkB,GAAI,YAAY,MAAM,WACP,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;IAClG,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IAC1E,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC5D,CAAC;AAEF,2EAA2E;AAC3E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,WAAW,EAAE,SAAS,CAAC;CACxB,CAAC;AAcF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,GACxB,SAAS,eAAe,EACxB,QAAQ,cAAc,KACrB,YAAY,GAAG,SAyHjB,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,oBAAoB,GAAG;IACjC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAC7D,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACpF,aAAa,EAAE,CACb,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAAE,KACxB,IAAI,CAAC;IACV,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAC7D,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAChE,CAAC;AAEF,8DAA8D;AAC9D,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,EACf,MAAM,YAAY,EAClB,UAAU,oBAAoB,SAwB/B,CAAC"}
+{"version":3,"file":"subtotal.d.ts","sourceRoot":"","sources":["../../../api/subtotal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EACL,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAC9B,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAYtE,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,0BAA0B,gBAAgB,CAAC;AACxD,eAAO,MAAM,kBAAkB,GAAI,YAAY,MAAM,WACP,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;IAClG,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IAC1E,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC5D,CAAC;AAEF,2EAA2E;AAC3E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,WAAW,EAAE,SAAS,CAAC;CACxB,CAAC;AAcF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,GACxB,SAAS,eAAe,EACxB,QAAQ,cAAc,KACrB,YAAY,GAAG,SA8HjB,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,oBAAoB,GAAG;IACjC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAC7D,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACpF,aAAa,EAAE,CACb,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAAE,KACxB,IAAI,CAAC;IACV,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAC7D,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAChE,CAAC;AAEF,8DAA8D;AAC9D,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,EACf,MAAM,YAAY,EAClB,UAAU,oBAAoB,SA0B/B,CAAC"}

package/dist/cjs/api/subtotal.js

@@ -127,9 +127,13 @@ export var planSubtotals = function (options, reader) {
         return values;
     };
     // "Replace current subtotals": the surviving data rows carry the previous
-    // outline (detail rows at 2, or deeper after repeated applies) into their
-    // final positions — the inserted total rows arrive at level 0 — so record
-    // how many ungroup steps each needs before the fresh levels go on.
+    // outline (detail rows at 2, or deeper after repeated applies) past the
+    // deletes, and a total row inserted below one of them would inherit that
+    // level (both engines give an inserted row the row above's outline level).
+    // So the reset runs between the deletes and the inserts, addressed to the
+    // compacted survivors — the k-th surviving data row sits at
+    // `firstDataRow + k` once the old total rows are gone — and records how
+    // many ungroup steps each needs before the fresh levels go on.
     var ungroupRows = [];
     var dataRowCursor = 0;
     var cursor = firstDataRow;
@@ -138,10 +142,11 @@ export var planSubtotals = function (options, reader) {
             var group = groups_1_1.value;
             var groupStart = cursor;
             for (var i = 0; i < group.size; i++) {
+                var compactedRow = firstDataRow + dataRowCursor;
                 var originalRow = dataRows[dataRowCursor++];
                 var level = replaceCurrent ? ((_d = (_c = reader.getOutlineLevel) === null || _c === void 0 ? void 0 : _c.call(reader, originalRow)) !== null && _d !== void 0 ? _d : 0) : 0;
                 for (var pass = 0; pass < level; pass++) {
-                    ((_e = ungroupRows[pass]) !== null && _e !== void 0 ? _e : (ungroupRows[pass] = [])).push(cursor);
+                    ((_e = ungroupRows[pass]) !== null && _e !== void 0 ? _e : (ungroupRows[pass] = [])).push(compactedRow);
                 }
                 detailRows.push(cursor++);
             }
@@ -189,9 +194,12 @@ export var applySubtotalPlan = function (sheetId, plan, executor) {
     if (plan.deleteRows.length)
         executor.onDeleteRow(sheetId, plan.deleteRows);
     try {
-        for (var _e = __values(plan.insertRows), _f = _e.next(); !_f.done; _f = _e.next()) {
-            var rowIndex = _f.value;
-            executor.onInsertRow(sheetId, rowIndex, 1);
+        // Outline reset before the inserts: the new total rows inherit the level of
+        // the row above them, which must already be 0 (see `SubtotalPlan`).
+        for (var _e = __values(plan.ungroupRows), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var rows = _f.value;
+            if (rows.length)
+                executor.onUngroupRows(sheetId, rows);
         }
     }
     catch (e_3_1) { e_3 = { error: e_3_1 }; }
@@ -202,14 +210,9 @@ export var applySubtotalPlan = function (sheetId, plan, executor) {
         finally { if (e_3) throw e_3.error; }
     }
     try {
-        for (var _g = __values(plan.writes), _h = _g.next(); !_h.done; _h = _g.next()) {
-            var write = _h.value;
-            executor.onChangeBatch(sheetId, {
-                startRowIndex: write.rowIndex,
-                endRowIndex: write.rowIndex,
-                startColumnIndex: write.startColumnIndex,
-                endColumnIndex: write.startColumnIndex + write.values.length - 1,
-            }, [write.values]);
+        for (var _g = __values(plan.insertRows), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var rowIndex = _h.value;
+            executor.onInsertRow(sheetId, rowIndex, 1);
         }
     }
     catch (e_4_1) { e_4 = { error: e_4_1 }; }
@@ -220,10 +223,14 @@ export var applySubtotalPlan = function (sheetId, plan, executor) {
         finally { if (e_4) throw e_4.error; }
     }
     try {
-        for (var _j = __values(plan.ungroupRows), _k = _j.next(); !_k.done; _k = _j.next()) {
-            var rows = _k.value;
-            if (rows.length)
-                executor.onUngroupRows(sheetId, rows);
+        for (var _j = __values(plan.writes), _k = _j.next(); !_k.done; _k = _j.next()) {
+            var write = _k.value;
+            executor.onChangeBatch(sheetId, {
+                startRowIndex: write.rowIndex,
+                endRowIndex: write.rowIndex,
+                startColumnIndex: write.startColumnIndex,
+                endColumnIndex: write.startColumnIndex + write.values.length - 1,
+            }, [write.values]);
         }
     }
     catch (e_5_1) { e_5 = { error: e_5_1 }; }

package/dist/cjs/api/table.d.ts

@@ -1,6 +1,17 @@
 import { type ParsedToken } from "@rowsncolumns/calculator";
-import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+import type { CellInterface, ExtendedValue, GridRange } from "@rowsncolumns/common-types";
 import type { BandedRange, FilterView, TableView } from "@rowsncolumns/spreadsheet";
+/**
+ * Excel's default for the Create Table dialog's "My table has headers": checked when the
+ * range's first row reads as a header row — it holds at least one value, every value in it is
+ * text (a number or boolean there means the data starts on the first row), and at least one row
+ * of data lies below it. A single-row range defaults to unchecked.
+ */
+export declare const guessTableHasHeaders: ({ sheetId, range, getEffectiveExtendedValue, }: {
+    sheetId: number;
+    range: GridRange;
+    getEffectiveExtendedValue: (sheetId: number, rowIndex: number, columnIndex: number) => ExtendedValue | null | undefined;
+}) => boolean;
 /**
  * Get table column index
  * @param sheetId
@@ -25,7 +36,20 @@ export declare const findAdjacentTable: (sheetId: number, cell: CellInterface, t
  * @returns
  */
 export declare const findAdjacentBandedRange: (sheetId: number, cell: CellInterface, bandedRanges: BandedRange[] | undefined, getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined) => readonly [BandedRange | undefined, boolean, boolean];
-export declare const isTableColumnCellsFillable: (sheetId: number, range: GridRange, excludeCell: CellInterface, existingColumnFormula: string | undefined, currentValue: string | boolean | undefined, activeSheetName: string, getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined) => boolean;
+/**
+ * Excel's calculated-column fill decision, shared with the Rust engine's
+ * `auto_fill_calculated_column` (rowsncolumns/spreadsheet#681): a formula just
+ * written into a table body cell fills the whole column when every OTHER body
+ * cell of that column is either empty (a fresh column) or holds the same
+ * formula relative to its row (a consistent calculated column, which the new
+ * formula overwrites). A literal anywhere, or two rows that disagree, leave
+ * the edit a one-cell exception. The column's cells are the reference — not
+ * the formula recorded on `columns[].formula`, which has no row of its own —
+ * so the overwrite works from any row, not only the one the column was
+ * created from (#668 T-50). A consistent column is a calculated column
+ * whatever its formula references (`=TODAY()`, `=1`), like Excel (#668 T-29).
+ */
+export declare const isTableColumnCellsFillable: (sheetId: number, range: GridRange, excludeCell: CellInterface, currentValue: string | boolean | undefined, activeSheetName: string, getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined) => boolean;
 export declare const addTableNameToTokens: (tokens: ParsedToken[], title: string) => string;
 export declare const removeTableName: (tokens: ParsedToken[], title: string) => string;
 /**

package/dist/cjs/api/table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../api/table.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAkBnC;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,uBAiBhC,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,0BAMvC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,EAC/B,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,uDAgDxB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,cAAc,WAAW,EAAE,GAAG,SAAS,EACvC,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,yDA8CxB,CAAC;AAGF,eAAO,MAAM,0BAA0B,GACrC,SAAS,MAAM,EACf,OAAO,SAAS,EAChB,aAAa,aAAa,EAC1B,uBAAuB,MAAM,GAAG,SAAS,EACzC,cAAc,MAAM,GAAG,OAAO,GAAG,SAAS,EAC1C,iBAAiB,MAAM,EACvB,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,YAsExB,CAAC;AAiCF,eAAO,MAAM,oBAAoB,GAAI,QAAQ,WAAW,EAAE,EAAE,OAAO,MAAM,WAyBxE,CAAC;AAcF,eAAO,MAAM,eAAe,GAAI,QAAQ,WAAW,EAAE,EAAE,OAAO,MAAM,WA2BnE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,SAAS,GAAG,UAAU,EAC7B,MAAM,MAAM,EAAE,EACd,gBAAgB,MAAM,SAoDvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,SAAS,GAAG,UAAU,EAC7B,MAAM,MAAM,EAAE,EACd,gBAAgB,MAAM,SAoDvB,CAAC"}
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../api/table.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAEjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,SAAS,EACV,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAmBnC;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,gDAIlC;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;IACjB,yBAAyB,EAAE,CACzB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,aAAa,GAAG,IAAI,GAAG,SAAS,CAAC;CACvC,KAAG,OA8BH,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,uBAiBhC,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,0BAMvC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,EAC/B,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,uDA8DxB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,cAAc,WAAW,EAAE,GAAG,SAAS,EACvC,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,yDA8CxB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,0BAA0B,GACrC,SAAS,MAAM,EACf,OAAO,SAAS,EAChB,aAAa,aAAa,EAC1B,cAAc,MAAM,GAAG,OAAO,GAAG,SAAS,EAC1C,iBAAiB,MAAM,EACvB,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,YAuDxB,CAAC;AAGF,eAAO,MAAM,oBAAoB,GAAI,QAAQ,WAAW,EAAE,EAAE,OAAO,MAAM,WAyBxE,CAAC;AAcF,eAAO,MAAM,eAAe,GAAI,QAAQ,WAAW,EAAE,EAAE,OAAO,MAAM,WA2BnE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,SAAS,GAAG,UAAU,EAC7B,MAAM,MAAM,EAAE,EACd,gBAAgB,MAAM,SAoDvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,SAAS,GAAG,UAAU,EAC7B,MAAM,MAAM,EAAE,EACd,gBAAgB,MAAM,SAoDvB,CAAC"}

package/dist/cjs/api/table.js

@@ -1,8 +1,7 @@
-var _a, _b, _c;
 import { __assign, __read, __spreadArray, __values } from "tslib";
-import { lexify, tokenVocabulary, } from "@rowsncolumns/calculator";
+import { tokenVocabulary, } from "@rowsncolumns/calculator";
 import { Direction } from "@rowsncolumns/common-types";
-import { isAFormula, isCellWithinBounds, isNil, iterateCellsInRange, } from "@rowsncolumns/utils";
+import { areaIntersects, isAFormula, isCellWithinBounds, isNil, iterateCellsInRange, } from "@rowsncolumns/utils";
 import { SheetCell } from "../sheet-cell";
 import { detokenize } from "./formula";
 import { moveFilterView, moveRange } from "./selection";
@@ -12,6 +11,35 @@ var isTableColumnToken = function (token) {
 var isTableNameToken = function (token) {
     return token.tokenType.name === tokenVocabulary.TableName.name;
 };
+/**
+ * Excel's default for the Create Table dialog's "My table has headers": checked when the
+ * range's first row reads as a header row — it holds at least one value, every value in it is
+ * text (a number or boolean there means the data starts on the first row), and at least one row
+ * of data lies below it. A single-row range defaults to unchecked.
+ */
+export var guessTableHasHeaders = function (_a) {
+    var _b, _c, _d;
+    var sheetId = _a.sheetId, range = _a.range, getEffectiveExtendedValue = _a.getEffectiveExtendedValue;
+    if (range.endRowIndex <= range.startRowIndex) {
+        return false;
+    }
+    var sawText = false;
+    for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+        var value = getEffectiveExtendedValue(sheetId, range.startRowIndex, columnIndex);
+        if (!value) {
+            continue;
+        }
+        if (!isNil((_b = value.nv) !== null && _b !== void 0 ? _b : value.numberValue) ||
+            !isNil((_c = value.bv) !== null && _c !== void 0 ? _c : value.boolValue)) {
+            return false;
+        }
+        var text = (_d = value.sv) !== null && _d !== void 0 ? _d : value.stringValue;
+        if (!isNil(text) && text !== "") {
+            sawText = true;
+        }
+    }
+    return sawText;
+};
 /**
  * Get table column index
  * @param sheetId
@@ -75,15 +103,25 @@ export var findAdjacentTable = function (sheetId, cell, tables, getUserEnteredVa
                 startColumnIndex: cell.columnIndex,
                 endColumnIndex: cell.columnIndex,
             }));
+        // Excel never merges tables: a line that belongs to another table is not free to grow over.
+        if (tables === null || tables === void 0 ? void 0 : tables.some(function (other) {
+            return other.id !== table.id &&
+                other.sheetId === sheetId &&
+                areaIntersects(other.range, lookupRange);
+        })) {
+            return false;
+        }
         return (isAdjacent &&
             __spreadArray([], __read(iterateCellsInRange(lookupRange)), false).every(function (_a) {
                 var _b = __read(_a, 2), rowIndex = _b[0], columnIndex = _b[1];
                 return isNil(getUserEnteredValue(sheetId, rowIndex, columnIndex));
             }));
     });
-    var totalRowOffset = (adjacentTable === null || adjacentTable === void 0 ? void 0 : adjacentTable.totalRow) ? 1 : 0;
+    // A table with a totals row never grows by rows (Excel): the cell right of its totals row is
+    // a column expansion only.
     var isRowExpansion = adjacentTable
-        ? adjacentTable.range.endRowIndex + 1 - totalRowOffset === cell.rowIndex
+        ? adjacentTable.range.endRowIndex + 1 === cell.rowIndex &&
+            !adjacentTable.totalRow
         : false;
     var isColumnExpansion = adjacentTable
         ? adjacentTable.range.endColumnIndex + 1 === cell.columnIndex
@@ -129,66 +167,61 @@ export var findAdjacentBandedRange = function (sheetId, cell, bandedRanges, getU
         : false;
     return [adjacentTable, isRowExpansion, isColumnExpansion];
 };
-// Check if table cells are fillable
-export var isTableColumnCellsFillable = function (sheetId, range, excludeCell, existingColumnFormula, currentValue, activeSheetName, getUserEnteredValue) {
-    var _a;
-    var normalizedExistingFormula = normalizeFormulaString(existingColumnFormula);
-    var normalizedCurrentFormula = isAFormula(currentValue)
-        ? normalizeFormulaString(currentValue)
-        : undefined;
-    var templateFormula = normalizedExistingFormula !== null && normalizedExistingFormula !== void 0 ? normalizedExistingFormula : normalizedCurrentFormula;
-    if (!templateFormula) {
-        return false;
-    }
-    var normalizedTemplate = (_a = SheetCell.getRelativeFormula(templateFormula, excludeCell, excludeCell, activeSheetName)) !== null && _a !== void 0 ? _a : templateFormula;
-    var templateHasReferences = formulaHasCellReferences(templateFormula);
-    var isAnchorCell = excludeCell.rowIndex === range.startRowIndex &&
-        excludeCell.columnIndex === range.startColumnIndex;
-    var normalizedCurrentLiteral = normalizeFormulaString(typeof currentValue === "string" ? currentValue : undefined);
-    if (normalizedExistingFormula && !templateHasReferences) {
+/**
+ * Excel's calculated-column fill decision, shared with the Rust engine's
+ * `auto_fill_calculated_column` (rowsncolumns/spreadsheet#681): a formula just
+ * written into a table body cell fills the whole column when every OTHER body
+ * cell of that column is either empty (a fresh column) or holds the same
+ * formula relative to its row (a consistent calculated column, which the new
+ * formula overwrites). A literal anywhere, or two rows that disagree, leave
+ * the edit a one-cell exception. The column's cells are the reference — not
+ * the formula recorded on `columns[].formula`, which has no row of its own —
+ * so the overwrite works from any row, not only the one the column was
+ * created from (#668 T-50). A consistent column is a calculated column
+ * whatever its formula references (`=TODAY()`, `=1`), like Excel (#668 T-29).
+ */
+export var isTableColumnCellsFillable = function (sheetId, range, excludeCell, currentValue, activeSheetName, getUserEnteredValue) {
+    var e_2, _a;
+    var _b;
+    if (!isAFormula(currentValue)) {
         return false;
     }
-    return __spreadArray([], __read(iterateCellsInRange(range)), false).every(function (_a) {
-        var _b = __read(_a, 2), rowIndex = _b[0], columnIndex = _b[1];
-        if (rowIndex === excludeCell.rowIndex &&
-            columnIndex === excludeCell.columnIndex) {
-            return true;
-        }
-        var userEnteredValue = getUserEnteredValue(sheetId, rowIndex, columnIndex);
-        if (isNil(userEnteredValue) || userEnteredValue === "") {
-            return true;
-        }
-        if (!isAFormula(userEnteredValue)) {
-            return false;
+    // The column's existing formula, relativised to the edited cell — every
+    // non-empty body cell must agree on it.
+    var existingTemplate;
+    try {
+        for (var _c = __values(iterateCellsInRange(range)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _e = __read(_d.value, 2), rowIndex = _e[0], columnIndex = _e[1];
+            if (rowIndex === excludeCell.rowIndex &&
+                columnIndex === excludeCell.columnIndex) {
+                continue;
+            }
+            var userEnteredValue = getUserEnteredValue(sheetId, rowIndex, columnIndex);
+            if (isNil(userEnteredValue) || userEnteredValue === "") {
+                continue;
+            }
+            if (!isAFormula(userEnteredValue)) {
+                return false;
+            }
+            // `$`-anchored references stay put from row to row (Excel), so they must
+            // not be shifted for the comparison.
+            var relativeFormula = (_b = SheetCell.getRelativeFormula(userEnteredValue, { rowIndex: rowIndex, columnIndex: columnIndex }, excludeCell, activeSheetName, undefined, false, undefined, undefined, true)) !== null && _b !== void 0 ? _b : userEnteredValue;
+            if (existingTemplate === undefined) {
+                existingTemplate = relativeFormula;
+            }
+            else if (existingTemplate !== relativeFormula) {
+                return false;
+            }
         }
-        var relativeFormula = SheetCell.getRelativeFormula(userEnteredValue, { rowIndex: rowIndex, columnIndex: columnIndex }, excludeCell, activeSheetName);
-        var comparable = relativeFormula !== null && relativeFormula !== void 0 ? relativeFormula : userEnteredValue;
-        return normalizedTemplate === comparable;
-    });
-};
-var formulaHasCellReferences = function (formula) {
-    if (!formula || typeof formula !== "string" || !formula.startsWith("=")) {
-        return false;
-    }
-    var tokens = lexify(formula).tokens;
-    return tokens.some(function (token) {
-        return CELL_REFERENCE_TOKEN_NAMES.has(token.tokenType.name);
-    });
-};
-var CELL_REFERENCE_TOKEN_NAMES = new Set([
-    (_a = tokenVocabulary.Cell) === null || _a === void 0 ? void 0 : _a.name,
-    (_b = tokenVocabulary.Column) === null || _b === void 0 ? void 0 : _b.name,
-    (_c = tokenVocabulary.TableColumnName) === null || _c === void 0 ? void 0 : _c.name,
-].filter(function (tokenName) { return Boolean(tokenName); }));
-var normalizeFormulaString = function (value) {
-    if (typeof value !== "string") {
-        return undefined;
     }
-    var trimmed = value.trim();
-    if (!trimmed) {
-        return undefined;
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_2) throw e_2.error; }
     }
-    return trimmed.startsWith("=") ? trimmed : "=".concat(trimmed);
+    return true;
 };
 // Add table name to formula
 export var addTableNameToTokens = function (tokens, title) {