@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/delete-table-column.js

@@ -0,0 +1,349 @@
+import { __assign, __read, __values } from "tslib";
+import { Direction } from "@rowsncolumns/common-types";
+import { getCellUserEnteredValue, getExtendedValueFormula } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
+import { contractRangesInFormula, createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { moveMergedCells } from "../api/merges";
+import { moveFilterView } from "../api/selection";
+import { SheetCell } from "../sheet-cell";
+export var deleteTableColumn = function (_a) {
+    var columnCount = _a.columnCount, rowCount = _a.rowCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, createHistory = _a.createHistory, onChangeTables = _a.onChangeTables, onChangeSheets = _a.onChangeSheets, onChangeSheetData = _a.onChangeSheetData, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, enqueueGraphOperation = _a.enqueueGraphOperation, getDependents = _a.getDependents;
+    return function (tableView, dimensionIndex) {
+        var sheetId = tableView.sheetId, range = tableView.range;
+        var saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        var referenceColumnIndex = tableView.range.startColumnIndex + dimensionIndex;
+        var minColumnIndex = referenceColumnIndex;
+        var count = 1;
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "delete-table-column",
+            sheetId: sheetId,
+            index: minColumnIndex,
+            count: count,
+            columnCount: columnCount,
+            startRowIndex: range.startRowIndex,
+            endRowIndex: range.endRowIndex,
+        });
+        // Update table position
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var e_1, _a, e_2, _b, e_3, _c;
+                var _d;
+                try {
+                    for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+                        var table_1 = draft_1_1.value;
+                        if (minColumnIndex < table_1.range.startColumnIndex &&
+                            table_1.range.startRowIndex >= tableView.range.startRowIndex &&
+                            table_1.range.endRowIndex <= tableView.range.endRowIndex &&
+                            table_1.id !== tableView.id) {
+                            moveFilterView(table_1, count, Direction.Left);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                var table = draft.find(function (table) { return table.id === tableView.id; });
+                if (table) {
+                    if (minColumnIndex >= table.range.startColumnIndex &&
+                        minColumnIndex <= table.range.endColumnIndex) {
+                        // Update filter specs for columns after
+                        if (table.filterSpecs) {
+                            try {
+                                for (var _e = __values(table.filterSpecs), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                    var spec = _f.value;
+                                    if (spec.columnIndex >= minColumnIndex) {
+                                        spec.columnIndex -= count;
+                                    }
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                        }
+                        // Update filter specs for columns after
+                        if (table.sortSpecs) {
+                            try {
+                                for (var _g = __values(table.sortSpecs), _h = _g.next(); !_h.done; _h = _g.next()) {
+                                    var spec = _h.value;
+                                    if (spec.dimensionIndex >= minColumnIndex) {
+                                        spec.dimensionIndex -= count;
+                                    }
+                                }
+                            }
+                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                            finally {
+                                try {
+                                    if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+                                }
+                                finally { if (e_3) throw e_3.error; }
+                            }
+                        }
+                        // Remove columns
+                        var columnArrayIndex = minColumnIndex - table.range.startColumnIndex;
+                        (_d = table.columns) === null || _d === void 0 ? void 0 : _d.splice(columnArrayIndex, count);
+                        table.range.endColumnIndex -= count;
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheets
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_4, _a, e_5, _b;
+                var _c;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    if (sheet.columnMetadata) {
+                        sheet.columnMetadata.splice(minColumnIndex, count);
+                    }
+                    if (sheet.basicFilter) {
+                        if (minColumnIndex < sheet.basicFilter.range.startColumnIndex) {
+                            moveFilterView(sheet.basicFilter, count, Direction.Left);
+                        }
+                        if (minColumnIndex > sheet.basicFilter.range.startColumnIndex &&
+                            minColumnIndex <= sheet.basicFilter.range.endColumnIndex) {
+                            // Update filter specs for columns after
+                            if (sheet.basicFilter.filterSpecs) {
+                                try {
+                                    for (var _d = __values(sheet.basicFilter.filterSpecs), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                        var spec = _e.value;
+                                        if (spec.columnIndex >= minColumnIndex) {
+                                            spec.columnIndex -= count;
+                                        }
+                                    }
+                                }
+                                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                finally {
+                                    try {
+                                        if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                                    }
+                                    finally { if (e_4) throw e_4.error; }
+                                }
+                            }
+                            // Update filter specs for columns after
+                            if (sheet.basicFilter.sortSpecs) {
+                                try {
+                                    for (var _f = __values(sheet.basicFilter.sortSpecs), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                        var spec = _g.value;
+                                        if (spec.dimensionIndex >= minColumnIndex) {
+                                            spec.dimensionIndex -= count;
+                                        }
+                                    }
+                                }
+                                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                finally {
+                                    try {
+                                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                                    }
+                                    finally { if (e_5) throw e_5.error; }
+                                }
+                            }
+                            sheet.basicFilter.range.endColumnIndex -= count;
+                        }
+                    }
+                    // Move merges
+                    if (sheet.merges) {
+                        sheet.merges = moveMergedCells(sheet.merges, "column-remove", minColumnIndex, count, function (area) {
+                            return (area.startRowIndex >= tableView.range.startRowIndex &&
+                                area.endRowIndex <= tableView.range.endRowIndex);
+                        });
+                    }
+                    sheet.columnCount = Math.max(1, ((_c = sheet.columnCount) !== null && _c !== void 0 ? _c : columnCount) - count);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_6, _a, e_7, _b;
+                var _c, _d, _e, _f, _g, _h, _j, _k, _l;
+                var sourceRange = __assign(__assign({}, range), { startColumnIndex: referenceColumnIndex + count });
+                var movedKeys = new Set();
+                /**
+                 * THREE-PASS FORMULA UPDATE STRATEGY FOR DELETION:
+                 *
+                 * PASS 1 (lines below): Contract ranges when deletion overlaps with them
+                 *   Example: Delete table column B, =SUM(A1:D1) → =SUM(A1:C1)
+                 *   Uses dependency graph to find only formulas that reference the deletion range (efficient!)
+                 *
+                 * PASS 2 (after this loop): Shift references in formulas that DEPEND ON the moved cells
+                 *   Example: If B10 is moved to A10, formulas referencing B10 must update
+                 *   Uses dependency graph to find only affected formulas (efficient)
+                 *
+                 * PASS 3 (final loop): Shift references in formulas WITHIN the moved cells themselves
+                 *   Example: If C10 contains =A1+A2 and moves to B10, references stay the same
+                 *   But if it contains =D1, it needs adjustment based on sourceRange exclusion
+                 *
+                 * The 'movedKeys' Set ensures no formula is processed twice across passes 2 & 3.
+                 * Range contraction (Pass 1) doesn't interfere with reference shifting (Pass 2 & 3).
+                 */
+                // PASS 1: Contract ranges using dependency graph (OPTIMIZED!)
+                // Collect formulas that reference cells in the deletion range
+                var deletionRange = {
+                    startRowIndex: range.startRowIndex,
+                    endRowIndex: range.endRowIndex,
+                    startColumnIndex: minColumnIndex,
+                    endColumnIndex: minColumnIndex + count - 1,
+                };
+                var formulasToContract = collectUniqueDependentsForRange({
+                    draft: draft,
+                    sheetId: sheetId,
+                    sourceRange: deletionRange,
+                    getDependents: getDependents,
+                });
+                var sheetCell = new SheetCell();
+                try {
+                    for (var _m = __values(formulasToContract.values()), _o = _m.next(); !_o.done; _o = _m.next()) {
+                        var pos = _o.value;
+                        var currentSheet = createSheetDraft(draft, 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];
+                        if (!cellData)
+                            continue;
+                        // Check if cell has a formula
+                        sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale: locale });
+                        var formulaValue = sheetCell.formula;
+                        if (formulaValue) {
+                            var activeSheetName = getSheetName(pos.sheetId);
+                            var contractedFormula = contractRangesInFormula(formulaValue, minColumnIndex, count, "column", activeSheetName);
+                            // Update the formula if it changed
+                            if (contractedFormula && contractedFormula !== formulaValue) {
+                                // Preserve stale effective value until recalculation completes
+                                sheetCell.setFormulaValue(contractedFormula, false);
+                                currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                                    sheetCell.getCellData();
+                                // Adjust column index for formulas to the right of the deleted column
+                                // (they will shift left by `count` after the splice)
+                                var adjustedColumnIndex = pos.sheetId === sheetId && pos.columnIndex > minColumnIndex
+                                    ? pos.columnIndex - count
+                                    : pos.columnIndex;
+                                enqueueCalculation === null || enqueueCalculation === void 0 ? void 0 : enqueueCalculation({
+                                    type: "add",
+                                    position: {
+                                        sheetId: pos.sheetId,
+                                        rowIndex: pos.rowIndex,
+                                        columnIndex: adjustedColumnIndex,
+                                    },
+                                    force: true,
+                                });
+                                recalcCells.set(createSheetCellIdentifier(pos.sheetId, pos.rowIndex, adjustedColumnIndex), {
+                                    sheetId: pos.sheetId,
+                                    rowIndex: pos.rowIndex,
+                                    columnIndex: adjustedColumnIndex,
+                                    force: true,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+                // PASS 2: Collect and process formulas that DEPEND ON the moved cells
+                var tableDependents = collectUniqueDependentsForRange({
+                    draft: draft,
+                    sheetId: sheetId,
+                    sourceRange: sourceRange,
+                    getDependents: getDependents,
+                });
+                try {
+                    for (var _p = __values(tableDependents.values()), _q = _p.next(); !_q.done; _q = _p.next()) {
+                        var pos = _q.value;
+                        moveFormulaAtPosition({
+                            draft: draft,
+                            position: pos,
+                            activeSheetName: getSheetName(pos.sheetId),
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            movedKeys: movedKeys,
+                            rowDelta: 0,
+                            columnDelta: -count,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (_q && !_q.done && (_b = _p.return)) _b.call(_p);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+                // PASS 3: Process formulas WITHIN the moved cells themselves
+                for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                    var rowValues = (_f = (_e = draft[sheetId]) === null || _e === void 0 ? void 0 : _e[rowIndex]) === null || _f === void 0 ? void 0 : _f.values;
+                    var dataColumnCount = (_g = rowValues === null || rowValues === void 0 ? void 0 : rowValues.length) !== null && _g !== void 0 ? _g : 0;
+                    if (!dataColumnCount) {
+                        continue;
+                    }
+                    var startCol = Math.min(Math.max(range.startColumnIndex, 1), dataColumnCount);
+                    var endCol = Math.min(range.endColumnIndex, dataColumnCount);
+                    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: 0,
+                            columnDelta: -count,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                    // Delete column values from the row
+                    if ((_j = (_h = draft[sheetId]) === null || _h === void 0 ? void 0 : _h[rowIndex]) === null || _j === void 0 ? void 0 : _j.values) {
+                        (_l = (_k = draft[sheetId][rowIndex]) === null || _k === void 0 ? void 0 : _k.values) === null || _l === void 0 ? void 0 : _l.splice(minColumnIndex, count);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/interface/delete-table-row.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import { type UseOnDeleteTableRowProps } from "../hooks/use-on-delete-table-row";
+export declare const deleteTableRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, }: UseOnDeleteTableRowProps<T, S>) => (tableView: TableView, rowIndexes: number[]) => void;
+//# sourceMappingURL=delete-table-row.d.ts.map

package/dist/cjs/interface/delete-table-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-table-row.d.ts","sourceRoot":"","sources":["../../../interface/delete-table-row.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAgB5E,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAIjF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kSAiBjE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MACvB,WAAW,SAAS,EAAE,YAAY,MAAM,EAAE,SAyXnD,CAAC"}