@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/api/structural-formula-update.js

@@ -0,0 +1,508 @@
+import { __assign, __values } from "tslib";
+import { isCellNode } from "@rowsncolumns/dag";
+import { getCellUserEnteredValue, getExtendedValueFormula, } from "@rowsncolumns/utils";
+import { SheetCell } from "../sheet-cell";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "./dependency";
+import { contractRangesInFormula, createSheetCellIdentifier, expandRangesInFormula, formulaToRelativeReference, } from "./formula";
+import { createSheetDraft } from "./immer-utils";
+/**
+ * Three-pass formula update for row/column insert and delete operations.
+ *
+ * PASS 1 — Range expansion / contraction:
+ *   Formulas that REFERENCE cells in the affected range have their range
+ *   references expanded (insert) or contracted (delete). e.g. inserting
+ *   a row at 2 turns `=SUM(A1:A10)` into `=SUM(A1:A11)`. We use the
+ *   dependency graph to find only the formulas that point INTO the
+ *   affected range, so this is O(dependents).
+ *
+ * PASS 2 — Reference shifting for outside-formulas pointing into the
+ *   moved region: every formula that referenced a cell in the source
+ *   range needs its references rebased by ±count along the axis. Again
+ *   uses the dependency graph, so O(dependents).
+ *
+ * PASS 3 — Reference shifting for formulas WITHIN the moved region:
+ *   formulas that live in the moved cells need their own references
+ *   rebased (with the moved region excluded so internal refs stay
+ *   stable). Replaced the historical O(rows × cols) cell sweep with a
+ *   graph-node lookup — only iterate cells the calculator already
+ *   knows are formula cells. O(formula_cells_in_workbook) with a sheet
+ *   + bounds filter, which on sparse-formula sheets (the common case)
+ *   is orders of magnitude smaller than the dense sweep.
+ *
+ * The `movedKeys` Set passed to `moveFormulaAtPosition` ensures Passes 2
+ * and 3 don't double-process a cell.
+ */
+export var updateFormulasForStructuralChange = function (params) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    var _e, _f, _g, _h, _j, _k;
+    var draft = params.draft, axis = params.axis, op = params.op, sheetId = params.sheetId, referenceIndex = params.referenceIndex, count = params.count, rowCount = params.rowCount, columnCount = params.columnCount, getDependents = params.getDependents, getGraphNodes = params.getGraphNodes, getGraphNodesInSheet = params.getGraphNodesInSheet, getSheetName = params.getSheetName, enqueueCalculation = params.enqueueCalculation, enqueueGraphOperation = params.enqueueGraphOperation, recalcCells = params.recalcCells, locale = params.locale, cellXfsRegistry = params.cellXfsRegistry, sharedStringRegistry = params.sharedStringRegistry;
+    if (count <= 0)
+        return;
+    var isRow = axis === "row";
+    var isInsert = op === "insert";
+    var delta = isInsert ? count : -count;
+    // The set of cells that ARE moving (Pass 3 target region). For both
+    // insert and delete, this is everything from the reference index along
+    // the affected axis; the splice happens after the formula updates.
+    var movedRegion = isRow
+        ? {
+            startRowIndex: referenceIndex,
+            endRowIndex: rowCount,
+            startColumnIndex: 1,
+            endColumnIndex: columnCount,
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: rowCount,
+            startColumnIndex: referenceIndex,
+            endColumnIndex: columnCount,
+        };
+    // Pass 1's affected range — the actual cells inserted (insert) or
+    // deleted (delete). For insert the cells don't exist yet, but we use
+    // the bounds to find formulas that reference them.
+    var pass1Range = isRow
+        ? {
+            startRowIndex: referenceIndex,
+            endRowIndex: referenceIndex + count - 1,
+            startColumnIndex: 1,
+            endColumnIndex: columnCount,
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: rowCount,
+            startColumnIndex: referenceIndex,
+            endColumnIndex: referenceIndex + count - 1,
+        };
+    // Pass 2's source range — the cells that will move under the splice.
+    // For insert this is everything at-or-after the insertion point; for
+    // delete this is everything strictly after the deleted block.
+    var pass2SourceRange = isRow
+        ? {
+            startRowIndex: isInsert ? referenceIndex : referenceIndex + count,
+            endRowIndex: rowCount,
+            startColumnIndex: 1,
+            endColumnIndex: columnCount,
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: rowCount,
+            startColumnIndex: isInsert ? referenceIndex : referenceIndex + count,
+            endColumnIndex: columnCount,
+        };
+    // ---- PASS 1 ----
+    var pass1Formulas = collectUniqueDependentsForRange({
+        draft: draft,
+        sheetId: sheetId,
+        sourceRange: pass1Range,
+        getDependents: getDependents,
+    });
+    if (pass1Formulas.size > 0) {
+        var sheetCell = new SheetCell();
+        try {
+            for (var _l = __values(pass1Formulas.values()), _m = _l.next(); !_m.done; _m = _l.next()) {
+                var pos = _m.value;
+                var currentSheet = createSheetDraft(draft, pos.sheetId, pos.rowIndex);
+                var cellData = (_f = (_e = currentSheet[pos.rowIndex]) === null || _e === void 0 ? void 0 : _e.values) === null || _f === void 0 ? void 0 : _f[pos.columnIndex];
+                if (!cellData)
+                    continue;
+                sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, sharedStringRegistry: sharedStringRegistry });
+                var formulaValue = sheetCell.formula;
+                if (!formulaValue)
+                    continue;
+                var activeSheetName = getSheetName(pos.sheetId);
+                var updatedFormula = isInsert
+                    ? expandRangesInFormula(formulaValue, referenceIndex, count, axis, activeSheetName)
+                    : contractRangesInFormula(formulaValue, referenceIndex, count, axis, activeSheetName);
+                if (!updatedFormula || updatedFormula === formulaValue)
+                    continue;
+                sheetCell.setFormulaValue(updatedFormula, false);
+                currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                    sheetCell.getCellData();
+                // Adjust the recalc position for cells that themselves shift in
+                // the splice that follows. For insert: cells AT or after the
+                // reference shift by +count along the axis. For delete: cells
+                // STRICTLY after the deleted block shift by -count.
+                var adjustedRowIndex = isRow
+                    ? pos.sheetId === sheetId &&
+                        (isInsert
+                            ? pos.rowIndex >= referenceIndex
+                            : pos.rowIndex >= referenceIndex + count)
+                        ? pos.rowIndex + delta
+                        : pos.rowIndex
+                    : pos.rowIndex;
+                var adjustedColumnIndex = !isRow
+                    ? pos.sheetId === sheetId &&
+                        (isInsert
+                            ? pos.columnIndex >= referenceIndex
+                            : pos.columnIndex >= referenceIndex + count)
+                        ? pos.columnIndex + delta
+                        : pos.columnIndex
+                    : pos.columnIndex;
+                enqueueCalculation === null || enqueueCalculation === void 0 ? void 0 : enqueueCalculation({
+                    type: "add",
+                    position: {
+                        sheetId: pos.sheetId,
+                        rowIndex: adjustedRowIndex,
+                        columnIndex: adjustedColumnIndex,
+                    },
+                    force: true,
+                });
+                recalcCells.set(createSheetCellIdentifier(pos.sheetId, adjustedRowIndex, adjustedColumnIndex), {
+                    sheetId: pos.sheetId,
+                    rowIndex: adjustedRowIndex,
+                    columnIndex: adjustedColumnIndex,
+                    force: true,
+                });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_m && !_m.done && (_a = _l.return)) _a.call(_l);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    // ---- PASS 2 ----
+    var movedKeys = new Set();
+    var rowDelta = isRow ? delta : 0;
+    var columnDelta = isRow ? 0 : delta;
+    var pass2Dependents = collectUniqueDependentsForRange({
+        draft: draft,
+        sheetId: sheetId,
+        sourceRange: pass2SourceRange,
+        getDependents: getDependents,
+    });
+    try {
+        for (var _o = __values(pass2Dependents.values()), _p = _o.next(); !_p.done; _p = _o.next()) {
+            var pos = _p.value;
+            if (pos.sheetId !== sheetId) {
+                shiftExternalDependentFormulaReferences({
+                    draft: draft,
+                    position: pos,
+                    editedSheetName: getSheetName(sheetId),
+                    enqueueCalculation: enqueueCalculation,
+                    enqueueGraphOperation: enqueueGraphOperation,
+                    recalcCells: recalcCells,
+                    movedKeys: movedKeys,
+                    rowDelta: rowDelta,
+                    columnDelta: columnDelta,
+                    sourceRange: pass2SourceRange,
+                    locale: locale,
+                    rowCount: rowCount,
+                    columnCount: columnCount,
+                    cellXfsRegistry: cellXfsRegistry,
+                    sharedStringRegistry: sharedStringRegistry,
+                });
+                continue;
+            }
+            moveFormulaAtPosition({
+                draft: draft,
+                position: pos,
+                activeSheetName: getSheetName(pos.sheetId),
+                enqueueCalculation: enqueueCalculation,
+                enqueueGraphOperation: enqueueGraphOperation,
+                recalcCells: recalcCells,
+                movedKeys: movedKeys,
+                rowDelta: rowDelta,
+                columnDelta: columnDelta,
+                sourceRange: pass2SourceRange,
+                locale: locale,
+                rowCount: rowCount,
+                columnCount: columnCount,
+                cellXfsRegistry: cellXfsRegistry,
+                sharedStringRegistry: sharedStringRegistry,
+            });
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_p && !_p.done && (_b = _o.return)) _b.call(_o);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    try {
+        // Some graph adapters do not return every direct cross-sheet formula from
+        // getDependents during a structural edit. Sweep the formula-node map as a
+        // fallback; movedKeys keeps dependents already handled above O(1) no-ops.
+        for (var _q = __values(collectExternalFormulaPositions(getGraphNodes, sheetId)), _r = _q.next(); !_r.done; _r = _q.next()) {
+            var position = _r.value;
+            shiftExternalDependentFormulaReferences({
+                draft: draft,
+                position: position,
+                editedSheetName: getSheetName(sheetId),
+                enqueueCalculation: enqueueCalculation,
+                enqueueGraphOperation: enqueueGraphOperation,
+                recalcCells: recalcCells,
+                movedKeys: movedKeys,
+                rowDelta: rowDelta,
+                columnDelta: columnDelta,
+                sourceRange: pass2SourceRange,
+                locale: locale,
+                rowCount: rowCount,
+                columnCount: columnCount,
+                cellXfsRegistry: cellXfsRegistry,
+                sharedStringRegistry: sharedStringRegistry,
+            });
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_r && !_r.done && (_c = _q.return)) _c.call(_q);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    // ---- PASS 3 ----
+    // Fast path: ask the calculator's dependency graph for the formula cells
+    // in this *sheet* (not the whole workbook) and filter to the moved
+    // region. With the per-sheet bucket the cost scales with
+    // `nodes_in_sheet`, which on multi-sheet workbooks is dramatically
+    // cheaper than walking every node in the graph.
+    //
+    // Fallback: when no graph (test harnesses) or no per-sheet bucket
+    // (e.g. nodes were added through a path that bypassed `createNode`),
+    // walk the draft directly so we don't silently drop formulas.
+    var graphFormulaPositions = collectGraphFormulaPositions(getGraphNodesInSheet, getGraphNodes, sheetId, movedRegion);
+    if (graphFormulaPositions) {
+        try {
+            for (var graphFormulaPositions_1 = __values(graphFormulaPositions), graphFormulaPositions_1_1 = graphFormulaPositions_1.next(); !graphFormulaPositions_1_1.done; graphFormulaPositions_1_1 = graphFormulaPositions_1.next()) {
+                var pos = graphFormulaPositions_1_1.value;
+                if (movedKeys.has(SheetCell.generateCellKey(sheetId, pos.rowIndex, pos.columnIndex))) {
+                    continue;
+                }
+                var rowValues = (_h = (_g = draft[sheetId]) === null || _g === void 0 ? void 0 : _g[pos.rowIndex]) === null || _h === void 0 ? void 0 : _h.values;
+                var cellData = rowValues === null || rowValues === void 0 ? void 0 : rowValues[pos.columnIndex];
+                var hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                if (!hasFormula)
+                    continue;
+                moveFormulaAtPosition({
+                    draft: draft,
+                    position: {
+                        sheetId: sheetId,
+                        rowIndex: pos.rowIndex,
+                        columnIndex: pos.columnIndex,
+                    },
+                    enqueueCalculation: enqueueCalculation,
+                    enqueueGraphOperation: enqueueGraphOperation,
+                    recalcCells: recalcCells,
+                    movedKeys: movedKeys,
+                    rowDelta: rowDelta,
+                    columnDelta: columnDelta,
+                    sourceRange: pass2SourceRange,
+                    locale: locale,
+                    rowCount: rowCount,
+                    columnCount: columnCount,
+                    cellXfsRegistry: cellXfsRegistry,
+                    sharedStringRegistry: sharedStringRegistry,
+                });
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (graphFormulaPositions_1_1 && !graphFormulaPositions_1_1.done && (_d = graphFormulaPositions_1.return)) _d.call(graphFormulaPositions_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    }
+    else {
+        var sheetRows = draft[sheetId];
+        if (!sheetRows)
+            return;
+        var startRow = movedRegion.startRowIndex;
+        var endRow = Math.min(movedRegion.endRowIndex, sheetRows.length - 1);
+        for (var rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
+            var rowValues = (_j = sheetRows[rowIndex]) === null || _j === void 0 ? void 0 : _j.values;
+            var dataColumnCount = (_k = rowValues === null || rowValues === void 0 ? void 0 : rowValues.length) !== null && _k !== void 0 ? _k : 0;
+            if (!dataColumnCount)
+                continue;
+            var startCol = Math.min(Math.max(movedRegion.startColumnIndex, 1), dataColumnCount);
+            var endCol = Math.min(movedRegion.endColumnIndex, dataColumnCount - 1);
+            for (var columnIndex = startCol; columnIndex <= endCol; columnIndex++) {
+                var cellData = rowValues === null || rowValues === void 0 ? void 0 : rowValues[columnIndex];
+                var hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                if (!hasFormula)
+                    continue;
+                moveFormulaAtPosition({
+                    draft: draft,
+                    position: { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex },
+                    enqueueCalculation: enqueueCalculation,
+                    enqueueGraphOperation: enqueueGraphOperation,
+                    recalcCells: recalcCells,
+                    movedKeys: movedKeys,
+                    rowDelta: rowDelta,
+                    columnDelta: columnDelta,
+                    sourceRange: pass2SourceRange,
+                    locale: locale,
+                    rowCount: rowCount,
+                    columnCount: columnCount,
+                    cellXfsRegistry: cellXfsRegistry,
+                    sharedStringRegistry: sharedStringRegistry,
+                });
+            }
+        }
+    }
+};
+var shiftExternalDependentFormulaReferences = function (_a) {
+    var _b, _c;
+    var draft = _a.draft, position = _a.position, editedSheetName = _a.editedSheetName, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, recalcCells = _a.recalcCells, movedKeys = _a.movedKeys, rowDelta = _a.rowDelta, columnDelta = _a.columnDelta, sourceRange = _a.sourceRange, locale = _a.locale, rowCount = _a.rowCount, columnCount = _a.columnCount, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
+    var sheetCell = new SheetCell();
+    var currentSheet = createSheetDraft(draft, position.sheetId, position.rowIndex);
+    var cellData = (_c = (_b = currentSheet[position.rowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[position.columnIndex];
+    sheetCell.assign(position.sheetId, { rowIndex: position.rowIndex, columnIndex: position.columnIndex }, cellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, sharedStringRegistry: sharedStringRegistry });
+    if (movedKeys.has(sheetCell.key) || !sheetCell.isFormula()) {
+        return;
+    }
+    movedKeys.add(sheetCell.key);
+    var previousFormula = sheetCell.formula;
+    var updatedFormula = formulaToRelativeReference(previousFormula, { rowIndex: position.rowIndex, columnIndex: position.columnIndex }, {
+        rowIndex: position.rowIndex + rowDelta,
+        columnIndex: position.columnIndex + columnDelta,
+    }, editedSheetName, {
+        exclusionRange: sourceRange,
+        rowCount: rowCount,
+        columnCount: columnCount,
+        referenceSheetName: editedSheetName,
+        includeUnqualifiedReferences: false,
+    });
+    if (!updatedFormula || updatedFormula === previousFormula) {
+        return;
+    }
+    sheetCell.setFormulaValue(updatedFormula, false);
+    currentSheet[position.rowIndex].values[position.columnIndex] =
+        sheetCell.getCellData();
+    var enqueueOperation = sheetCell.ephemeral()
+        ? enqueueCalculation
+        : enqueueGraphOperation;
+    enqueueOperation === null || enqueueOperation === void 0 ? void 0 : enqueueOperation({ type: "remove", position: position });
+    enqueueOperation === null || enqueueOperation === void 0 ? void 0 : enqueueOperation({ type: "add", position: position, force: true });
+    recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), __assign(__assign({}, position), { force: true }));
+};
+var collectExternalFormulaPositions = function (getGraphNodes, editedSheetId) {
+    var e_5, _a;
+    if (!getGraphNodes)
+        return [];
+    var graphNodes;
+    try {
+        graphNodes = getGraphNodes();
+    }
+    catch (_b) {
+        return [];
+    }
+    if (!graphNodes || typeof graphNodes.values !== "function")
+        return [];
+    var positions = [];
+    try {
+        for (var _c = __values(graphNodes.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var node = _d.value;
+            if (!isCellNode(node) || node.position.sheetId === editedSheetId) {
+                continue;
+            }
+            positions.push(node.position);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return positions;
+};
+/**
+ * Returns formula-cell positions from the dependency graph filtered to a
+ * single sheet and range. Returns `null` when the graph has no nodes for
+ * this sheet — the caller should fall back to a cell sweep.
+ *
+ * Prefers the per-sheet bucket (`getGraphNodesInSheet`) which scales with
+ * `nodes_in_sheet` rather than `nodes_in_workbook`. Falls through to the
+ * workbook-wide map only when the per-sheet API isn't available.
+ */
+var collectGraphFormulaPositions = function (getGraphNodesInSheet, getGraphNodes, sheetId, movedRegion) {
+    var e_6, _a, e_7, _b;
+    // Fast path: per-sheet bucket.
+    if (getGraphNodesInSheet) {
+        var sheetBucket = void 0;
+        try {
+            sheetBucket = getGraphNodesInSheet(sheetId);
+        }
+        catch (_c) {
+            sheetBucket = undefined;
+        }
+        if (sheetBucket &&
+            typeof sheetBucket.values === "function") {
+            var positions_1 = [];
+            try {
+                for (var _d = __values(sheetBucket.values()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var node = _e.value;
+                    if (!isCellNode(node))
+                        continue;
+                    var pos = node.position;
+                    if (pos.rowIndex < movedRegion.startRowIndex ||
+                        pos.rowIndex > movedRegion.endRowIndex ||
+                        pos.columnIndex < movedRegion.startColumnIndex ||
+                        pos.columnIndex > movedRegion.endColumnIndex) {
+                        continue;
+                    }
+                    positions_1.push({
+                        rowIndex: pos.rowIndex,
+                        columnIndex: pos.columnIndex,
+                    });
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            return positions_1;
+        }
+    }
+    // Fallback: workbook-wide map (older calculators or test stubs).
+    if (!getGraphNodes)
+        return null;
+    var graphNodes;
+    try {
+        graphNodes = getGraphNodes();
+    }
+    catch (_f) {
+        return null;
+    }
+    if (!graphNodes ||
+        typeof graphNodes.values !== "function") {
+        return null;
+    }
+    var positions = [];
+    var sawSheetNode = false;
+    try {
+        for (var _g = __values(graphNodes.values()), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var node = _h.value;
+            if (!isCellNode(node))
+                continue;
+            var pos = node.position;
+            if (pos.sheetId !== sheetId)
+                continue;
+            sawSheetNode = true;
+            if (pos.rowIndex < movedRegion.startRowIndex ||
+                pos.rowIndex > movedRegion.endRowIndex ||
+                pos.columnIndex < movedRegion.startColumnIndex ||
+                pos.columnIndex > movedRegion.endColumnIndex) {
+                continue;
+            }
+            positions.push({ rowIndex: pos.rowIndex, columnIndex: pos.columnIndex });
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return sawSheetNode ? positions : null;
+};

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

@@ -0,0 +1,39 @@
+import { type ParsedToken } from "@rowsncolumns/calculator";
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+import type { BandedRange, FilterView, TableView } from "@rowsncolumns/spreadsheet";
+/**
+ * Get table column index
+ * @param sheetId
+ * @param cell
+ * @param tables
+ */
+export declare const findTableColumnIndex: (sheetId: number, cell: CellInterface, tables: TableView[] | undefined) => number | undefined;
+export declare const findActiveTableWithinCell: (sheetId: number, cell: CellInterface, tables: TableView[] | undefined | null) => TableView | undefined;
+/**
+ * Find table adjacent to a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+export declare const findAdjacentTable: (sheetId: number, cell: CellInterface, tables: TableView[] | undefined, getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined) => readonly [TableView | undefined, boolean, boolean];
+/**
+ * Find table adjacent to a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @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;
+export declare const addTableNameToTokens: (tokens: ParsedToken[], title: string) => string;
+export declare const removeTableName: (tokens: ParsedToken[], title: string) => string;
+/**
+ * Shift tables
+ */
+export declare const shiftTableMovingRows: (table: TableView | FilterView, dims: number[], referenceIndex: number) => void;
+/**
+ * Shift tables
+ */
+export declare const shiftTableMovingColumns: (table: TableView | FilterView, dims: number[], referenceIndex: number) => void;
+//# sourceMappingURL=table.d.ts.map

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

@@ -0,0 +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"}