@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/interface/insert-cells-shift-right.js

@@ -0,0 +1,134 @@
+import { createArrayRange, selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { processSideEffectDependentCells } from "../api/dependency";
+import { cloneCellWithFormatting } from "../api/immer-utils";
+import { moveMergedCells } from "../api/merges";
+export const insertCellsShiftRight = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }) => {
+    return (sheetId, activeCell, selections) => {
+        const saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // Count
+        const finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        // Last selection
+        const selection = finalSelections[finalSelections.length - 1];
+        const count = selection.range.endRowIndex - selection.range.startRowIndex + 1;
+        enqueueStructureChange?.({
+            kind: "insert-cells-shift-right",
+            sheetId,
+            startRowIndex: selection.range.startRowIndex,
+            endRowIndex: selection.range.endRowIndex,
+            startColumnIndex: selection.range.startColumnIndex,
+            endColumnIndex: selection.range.endColumnIndex,
+            columnCount,
+        });
+        // Update sheets
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                        if (sheet.merges) {
+                            sheet.merges = moveMergedCells(sheet.merges, "column-insert", columnIndex);
+                        }
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update citations - shift if in affected rows and after insertion column
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                const affectedRowStart = selection.range.startRowIndex;
+                const affectedRowEnd = selection.range.endRowIndex;
+                const insertColumnStart = selection.range.startColumnIndex;
+                const shiftAmount = selection.range.endColumnIndex -
+                    selection.range.startColumnIndex +
+                    1;
+                for (const citation of draft) {
+                    // Skip citations on other sheets
+                    if (citation.range.sheetId !== sheetId) {
+                        continue;
+                    }
+                    // Check if citation overlaps with affected rows
+                    const citationRowStart = citation.range.startRowIndex;
+                    const citationRowEnd = citation.range.endRowIndex;
+                    const rowsOverlap = !(citationRowEnd < affectedRowStart ||
+                        citationRowStart > affectedRowEnd);
+                    if (rowsOverlap) {
+                        // If citation starts at or after the insertion column, shift it right
+                        if (citation.range.startColumnIndex >= insertColumnStart) {
+                            citation.range.startColumnIndex += shiftAmount;
+                            citation.range.endColumnIndex += shiftAmount;
+                        }
+                    }
+                }
+            });
+            saveHistory({
+                citations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const movedKeys = new Set();
+                for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                    const totalColumns = draft[sheetId]?.[rowIndex]?.values?.length ?? columnCount;
+                    for (let columnIndex = 1; columnIndex < totalColumns; columnIndex++) {
+                        const sourceRange = {
+                            ...selection.range,
+                            endColumnIndex: totalColumns,
+                        };
+                        // Process dependents
+                        processSideEffectDependentCells({
+                            draft,
+                            rowIndex,
+                            columnIndex,
+                            sheetId,
+                            columnDelta: count,
+                            enqueueGraphOperation,
+                            enqueueCalculation,
+                            getDependents,
+                            recalcCells,
+                            rowDelta: 0,
+                            sourceRange,
+                            movedKeys,
+                            locale,
+                            rowCount,
+                            columnCount,
+                            cellXfsRegistry,
+                            sharedStringRegistry,
+                        });
+                    }
+                }
+                // Delete column
+                for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                    // Delete column
+                    if (draft[sheetId]?.[rowIndex]?.values) {
+                        draft[sheetId][rowIndex]?.values?.splice(selection.range.startColumnIndex, 0, ...createArrayRange(selection.range.startColumnIndex, selection.range.endColumnIndex).map((columnIndex) => {
+                            return cloneCellWithFormatting(draft[sheetId][rowIndex]?.values?.[columnIndex]);
+                        }));
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+                selections: {
+                    undo: [...getSelections()],
+                    redo: [...getSelections()],
+                },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/insert-column.d.ts

@@ -0,0 +1,7 @@
+import { Direction } from "@rowsncolumns/common-types";
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseOnInsertColumnProps } from "../hooks/use-on-insert-column";
+import type { UseOnTableProps } from "../hooks/use-on-table";
+export declare const insertColumn: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, tables, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, getGraphNodes, getGraphNodesInSheet, getActiveCell, getSelections, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, generatedNames, }: UseOnInsertColumnProps<T, S>) => (sheetId: number, referenceColumnIndex: number, numColumns?: number) => void;
+export declare const insertTableColumn: <T extends CellData, S extends Sheet>({ tables, columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, generatedNames, }: Pick<UseOnTableProps<T, S>, "tables" | "columnCount" | "rowCount" | "locale" | "cellXfsRegistry" | "sharedStringRegistry" | "createHistory" | "onChangeTables" | "onChangeSheets" | "onChangeSheetData" | "enqueueCalculation" | "enqueueStructureChange" | "enqueueGraphOperation" | "getDependents" | "getSheetName" | "generatedNames">) => (tableView: TableView, dimensionIndex: number, direction: Direction.Left | Direction.Right) => void;
+//# sourceMappingURL=insert-column.d.ts.map

package/dist/esm/interface/insert-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-column.d.ts","sourceRoot":"","sources":["../../../interface/insert-column.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAoB5E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qaAyB/D,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,MACrB,SAAS,MAAM,EAAE,sBAAsB,MAAM,EAAE,mBAAc,SA0TtE,CAAC;AAMF,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qQAiBpE,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,QAAQ,GACR,aAAa,GACb,UAAU,GACV,QAAQ,GACR,iBAAiB,GACjB,sBAAsB,GACtB,eAAe,GACf,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,oBAAoB,GACpB,wBAAwB,GACxB,uBAAuB,GACvB,eAAe,GACf,cAAc,GACd,gBAAgB,CACnB,MAEG,WAAW,SAAS,EACpB,gBAAgB,MAAM,EACtB,WAAW,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,KAAK,SA4V9C,CAAC"}

package/dist/esm/interface/insert-column.js

@@ -0,0 +1,481 @@
+import { Direction } from "@rowsncolumns/common-types";
+import { produceWithPatches } from "immer";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
+import { createSheetCellIdentifier, expandRangesInFormula, } from "../api/formula";
+import { cloneCellWithFormatting, createSheetDraft } from "../api/immer-utils";
+import { expandMergesOnColumnInsert, moveMergedCells } from "../api/merges";
+import { shiftPivotsOnInsert } from "../api/pivot-range";
+import { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
+import { moveFilterView } from "../api/selection";
+import { updateFormulasForStructuralChange } from "../api/structural-formula-update";
+import { getGeneratedTableColumnName } from "../generated-names";
+import { getNextTableColumnName } from "../helpers";
+import { SheetCell } from "../sheet-cell";
+export const insertColumn = ({ rowCount, columnCount, locale, tables, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, getGraphNodes, getGraphNodesInSheet, getActiveCell, getSelections, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, generatedNames, }) => {
+    return (sheetId, referenceColumnIndex, numColumns = 1) => {
+        if (numColumns <= 0)
+            return;
+        enqueueStructureChange?.({
+            kind: "insert-column",
+            sheetId,
+            index: referenceColumnIndex,
+            count: numColumns,
+            rowCount,
+            columnCount,
+        });
+        const saveHistory = createHistory();
+        const recalcCells = new Map();
+        // Tables: shift / extend, plus column-specific filter+sort spec updates
+        // and per-table column-header insertion.
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    if (table.sheetId !== sheetId)
+                        continue;
+                    if (referenceColumnIndex <= table.range.startColumnIndex) {
+                        moveFilterView(table, numColumns, Direction.Right);
+                    }
+                    if (referenceColumnIndex >= table.range.startColumnIndex &&
+                        referenceColumnIndex <= table.range.endColumnIndex) {
+                        const tableColumnIndex = referenceColumnIndex - table.range.startColumnIndex;
+                        const newColumns = [];
+                        for (let i = 0; i < numColumns; i++) {
+                            const columnName = getNextTableColumnName([...(table.columns || []), ...newColumns], generatedNames);
+                            newColumns.push({ name: columnName });
+                        }
+                        table.columns?.splice(tableColumnIndex, 0, ...newColumns);
+                        if (table.filterSpecs) {
+                            for (const spec of table.filterSpecs) {
+                                if (spec.columnIndex >= referenceColumnIndex) {
+                                    spec.columnIndex += numColumns;
+                                }
+                            }
+                        }
+                        if (table.sortSpecs) {
+                            for (const spec of table.sortSpecs) {
+                                if (spec.dimensionIndex >= referenceColumnIndex) {
+                                    spec.dimensionIndex += numColumns;
+                                }
+                            }
+                        }
+                        table.range.endColumnIndex += numColumns;
+                    }
+                }
+            });
+            saveHistory({ tables: { patches, inversePatches } });
+            return nextState;
+        });
+        // Data validations
+        onChangeDataValidations?.((prevValidations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
+                updateRangedRulesOnStructuralChange(draft, "insert", "column", referenceColumnIndex, numColumns, sheetId);
+            });
+            saveHistory({ dataValidations: { patches, inversePatches } });
+            return nextState;
+        });
+        // Conditional formats
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                updateRangedRulesOnStructuralChange(draft, "insert", "column", referenceColumnIndex, numColumns, sheetId);
+            });
+            saveHistory({ conditionalFormats: { patches, inversePatches } });
+            return nextState;
+        });
+        // Shift pivot tables.
+        onChangePivotTables?.((prevPivots) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevPivots, (draft) => {
+                shiftPivotsOnInsert(draft, sheetId, "column", referenceColumnIndex, numColumns);
+            });
+            saveHistory({ pivotTables: { patches, inversePatches } });
+            return nextState;
+        });
+        // Citations: shift only when insertion is BEFORE the citation range.
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                for (const citation of draft) {
+                    if (citation.range.sheetId !== sheetId)
+                        continue;
+                    if (referenceColumnIndex <= citation.range.startColumnIndex) {
+                        citation.range.startColumnIndex += numColumns;
+                        citation.range.endColumnIndex += numColumns;
+                    }
+                }
+            });
+            saveHistory({ citations: { patches, inversePatches } });
+            return nextState;
+        });
+        // Sheet metadata
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (!sheet)
+                    return;
+                if (sheet.columnMetadata) {
+                    sheet.columnMetadata.splice(referenceColumnIndex, 0, ...Array.from({ length: numColumns }, () => null));
+                }
+                if (sheet.basicFilter) {
+                    const { startColumnIndex, endColumnIndex } = sheet.basicFilter.range;
+                    if (startColumnIndex >= referenceColumnIndex) {
+                        moveFilterView(sheet.basicFilter, numColumns, Direction.Right);
+                    }
+                    if (referenceColumnIndex >= startColumnIndex &&
+                        referenceColumnIndex <= endColumnIndex) {
+                        if (sheet.basicFilter.filterSpecs) {
+                            for (const spec of sheet.basicFilter.filterSpecs) {
+                                if (spec.columnIndex >= referenceColumnIndex) {
+                                    spec.columnIndex += numColumns;
+                                }
+                            }
+                        }
+                        if (sheet.basicFilter.sortSpecs) {
+                            for (const spec of sheet.basicFilter.sortSpecs) {
+                                if (spec.dimensionIndex >= referenceColumnIndex) {
+                                    spec.dimensionIndex += numColumns;
+                                }
+                            }
+                        }
+                        sheet.basicFilter.range.endColumnIndex += numColumns;
+                    }
+                }
+                if (sheet.frozenColumnCount &&
+                    referenceColumnIndex <= sheet.frozenColumnCount) {
+                    sheet.frozenColumnCount += numColumns;
+                }
+                if (sheet.merges) {
+                    sheet.merges = expandMergesOnColumnInsert(sheet.merges, referenceColumnIndex, numColumns);
+                }
+                sheet.columnCount = (sheet.columnCount ?? columnCount) + numColumns;
+            });
+            saveHistory({ sheets: { patches, inversePatches } });
+            return nextState;
+        });
+        // Sheet data: three-pass formula update, then per-row column splice and
+        // table-column header generation.
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                updateFormulasForStructuralChange({
+                    draft,
+                    axis: "column",
+                    op: "insert",
+                    sheetId,
+                    referenceIndex: referenceColumnIndex,
+                    count: numColumns,
+                    rowCount,
+                    columnCount,
+                    getDependents,
+                    getGraphNodes,
+                    getGraphNodesInSheet,
+                    getSheetName,
+                    enqueueCalculation,
+                    enqueueGraphOperation,
+                    recalcCells,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+                // Insert columns into each row's values array.
+                const sheetRows = draft[sheetId];
+                if (sheetRows) {
+                    for (let rowIndex = 1; rowIndex < sheetRows.length; rowIndex++) {
+                        const row = sheetRows[rowIndex];
+                        if (!row?.values)
+                            continue;
+                        if (row.values.length > referenceColumnIndex) {
+                            const formattingSource = row.values[referenceColumnIndex] ??
+                                row.values[referenceColumnIndex - 1] ??
+                                undefined;
+                            const newColumns = Array.from({ length: numColumns }, () => cloneCellWithFormatting(formattingSource));
+                            row.values.splice(referenceColumnIndex, 0, ...newColumns);
+                        }
+                    }
+                }
+                // Add table column headers for any table whose header row was
+                // affected by the insertion.
+                for (const { range, sheetId: tSheetId, headerRow, columns } of tables ?? []) {
+                    if (tSheetId !== sheetId ||
+                        !headerRow ||
+                        referenceColumnIndex <= range.startColumnIndex ||
+                        referenceColumnIndex > range.endColumnIndex) {
+                        continue;
+                    }
+                    const currentSheet = createSheetDraft(draft, tSheetId, range.startRowIndex);
+                    for (let i = 0; i < numColumns; i++) {
+                        const currentColumnIndex = referenceColumnIndex + i;
+                        const formattingSource = cloneCellWithFormatting(draft[tSheetId]?.[range.startRowIndex]?.values?.[currentColumnIndex]);
+                        const existingColumns = [...(columns || [])];
+                        for (let j = 0; j < i; j++) {
+                            existingColumns.push({
+                                name: getGeneratedTableColumnName(j + 1, generatedNames),
+                            });
+                        }
+                        const columnName = getNextTableColumnName(existingColumns, generatedNames);
+                        const sheetCell = new SheetCell(tSheetId, {
+                            rowIndex: range.startRowIndex,
+                            columnIndex: currentColumnIndex,
+                        }, formattingSource);
+                        sheetCell.setUserEnteredValue(columnName);
+                        currentSheet[range.startRowIndex].values[currentColumnIndex] =
+                            sheetCell.getCellData();
+                    }
+                }
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+                selections: {
+                    undo: [...getSelections()],
+                    redo: [...getSelections()],
+                },
+            });
+            return nextState;
+        });
+    };
+};
+// `insertTableColumn` is a separate operation (insert a single column into an
+// existing table view) and uses the legacy three-pass logic below. Worth
+// migrating to the shared helper later but leaving it untouched here to keep
+// scope tight.
+export const insertTableColumn = ({ tables, columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, generatedNames, }) => {
+    return (tableView, dimensionIndex, direction) => {
+        const { sheetId } = tableView;
+        const numColumns = 1;
+        const saveHistory = createHistory();
+        const recalcCells = new Map();
+        let referenceColumnIndex = tableView.range.startColumnIndex + dimensionIndex;
+        const realReferenceColumnIndex = referenceColumnIndex;
+        if (direction === Direction.Right) {
+            referenceColumnIndex++;
+        }
+        enqueueStructureChange?.({
+            kind: "insert-table-column",
+            sheetId,
+            index: referenceColumnIndex,
+            count: numColumns,
+            columnCount,
+            startRowIndex: tableView.range.startRowIndex,
+            endRowIndex: tableView.range.endRowIndex,
+        });
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    if (referenceColumnIndex < table.range.startColumnIndex &&
+                        table.range.startRowIndex >= tableView.range.startRowIndex &&
+                        table.range.endRowIndex <= tableView.range.endRowIndex &&
+                        table.id !== tableView.id) {
+                        moveFilterView(table, numColumns, Direction.Right);
+                    }
+                }
+                const table = draft.find((table) => table.id == tableView.id);
+                if (table) {
+                    if (referenceColumnIndex >= table.range.startColumnIndex &&
+                        referenceColumnIndex <= table.range.endColumnIndex + numColumns) {
+                        const tableColumnIndex = referenceColumnIndex - table.range.startColumnIndex;
+                        const columnName = getNextTableColumnName(table.columns ?? undefined, generatedNames);
+                        table.columns?.splice(tableColumnIndex, 0, { name: columnName });
+                        if (table.filterSpecs) {
+                            for (const spec of table.filterSpecs) {
+                                if (spec.columnIndex >= referenceColumnIndex) {
+                                    spec.columnIndex += numColumns;
+                                }
+                            }
+                        }
+                        if (table.sortSpecs) {
+                            for (const spec of table.sortSpecs) {
+                                if (spec.dimensionIndex >= referenceColumnIndex) {
+                                    spec.dimensionIndex += numColumns;
+                                }
+                            }
+                        }
+                        table.range.endColumnIndex += numColumns;
+                    }
+                }
+            });
+            saveHistory({ tables: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (!sheet)
+                    return;
+                if (sheet.columnMetadata) {
+                    const newColumnMetadata = [...Array(numColumns)].map((_, index) => sheet.columnMetadata?.[referenceColumnIndex + index]);
+                    sheet.columnMetadata.splice(referenceColumnIndex, 0, ...newColumnMetadata);
+                }
+                if (sheet.basicFilter) {
+                    if (sheet.basicFilter.range.startColumnIndex >= referenceColumnIndex) {
+                        moveFilterView(sheet.basicFilter, numColumns, Direction.Right);
+                    }
+                    if (referenceColumnIndex >=
+                        sheet.basicFilter.range.startColumnIndex &&
+                        referenceColumnIndex <= sheet.basicFilter.range.endColumnIndex) {
+                        if (sheet.basicFilter.filterSpecs) {
+                            for (const spec of sheet.basicFilter.filterSpecs) {
+                                if (spec.columnIndex >= referenceColumnIndex) {
+                                    spec.columnIndex += numColumns;
+                                }
+                            }
+                        }
+                        if (sheet.basicFilter.sortSpecs) {
+                            for (const spec of sheet.basicFilter.sortSpecs) {
+                                if (spec.dimensionIndex >= referenceColumnIndex) {
+                                    spec.dimensionIndex += numColumns;
+                                }
+                            }
+                        }
+                        sheet.basicFilter.range.endColumnIndex += numColumns;
+                    }
+                }
+                if (sheet.merges) {
+                    sheet.merges = moveMergedCells(sheet.merges, "column-insert", referenceColumnIndex, numColumns, (area) => {
+                        return (area.startRowIndex >= tableView.range.startRowIndex &&
+                            area.endRowIndex <= tableView.range.endRowIndex);
+                    });
+                }
+                sheet.columnCount = (sheet.columnCount ?? columnCount) + numColumns;
+            });
+            saveHistory({ sheets: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const { range } = tableView;
+                const headerRow = tableView.headerRow ?? true;
+                const sourceRange = {
+                    ...range,
+                    startColumnIndex: referenceColumnIndex,
+                };
+                const movedKeys = new Set();
+                // PASS 1
+                const insertionRange = {
+                    startRowIndex: 1,
+                    endRowIndex: rowCount,
+                    startColumnIndex: referenceColumnIndex,
+                    endColumnIndex: referenceColumnIndex + numColumns - 1,
+                };
+                const formulasToExpand = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange: insertionRange,
+                    getDependents,
+                });
+                const sheetCell = new SheetCell();
+                for (const pos of formulasToExpand.values()) {
+                    const currentSheet = createSheetDraft(draft, sheetId, pos.rowIndex);
+                    const cellData = currentSheet[pos.rowIndex]?.values?.[pos.columnIndex];
+                    if (!cellData)
+                        continue;
+                    sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData);
+                    const formulaValue = sheetCell.formula;
+                    if (!formulaValue)
+                        continue;
+                    const activeSheetName = getSheetName(pos.sheetId);
+                    const expandedFormula = expandRangesInFormula(formulaValue, referenceColumnIndex, numColumns, "column", activeSheetName);
+                    if (!expandedFormula || expandedFormula === formulaValue)
+                        continue;
+                    sheetCell.setFormulaValue(expandedFormula, false);
+                    currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                        sheetCell.getCellData();
+                    const adjustedColumnIndex = pos.sheetId === sheetId &&
+                        pos.columnIndex >= referenceColumnIndex
+                        ? pos.columnIndex + numColumns
+                        : pos.columnIndex;
+                    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,
+                    });
+                }
+                // PASS 2
+                const tableDependents = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange,
+                    getDependents,
+                });
+                for (const pos of tableDependents.values()) {
+                    moveFormulaAtPosition({
+                        draft,
+                        position: pos,
+                        activeSheetName: getSheetName(pos.sheetId),
+                        enqueueCalculation,
+                        enqueueGraphOperation,
+                        recalcCells,
+                        movedKeys,
+                        rowDelta: 0,
+                        columnDelta: numColumns,
+                        sourceRange,
+                        locale,
+                        rowCount,
+                        columnCount,
+                        cellXfsRegistry,
+                        sharedStringRegistry,
+                    });
+                }
+                // PASS 3 (table-bounded)
+                for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                    const dataColumnCount = draft[sheetId]?.[rowIndex]?.values?.length ?? 0;
+                    const startCol = Math.min(Math.max(referenceColumnIndex, 1), dataColumnCount);
+                    const endCol = Math.min(range.endColumnIndex + numColumns, dataColumnCount);
+                    for (let columnIndex = startCol; columnIndex < endCol; columnIndex++) {
+                        moveFormulaAtPosition({
+                            draft,
+                            position: { sheetId, rowIndex, columnIndex },
+                            enqueueCalculation,
+                            enqueueGraphOperation,
+                            recalcCells,
+                            movedKeys,
+                            rowDelta: 0,
+                            columnDelta: numColumns,
+                            sourceRange,
+                            locale,
+                            rowCount,
+                            columnCount,
+                            cellXfsRegistry,
+                            sharedStringRegistry,
+                        });
+                    }
+                }
+                // Insert column cells
+                for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                    if (draft[sheetId]?.[rowIndex]?.values) {
+                        const formattingSource = draft[sheetId]?.[rowIndex]?.values?.[realReferenceColumnIndex] ??
+                            draft[sheetId]?.[rowIndex]?.values?.[realReferenceColumnIndex - 1] ??
+                            undefined;
+                        const newColumns = Array.from({ length: numColumns }).map(() => cloneCellWithFormatting(formattingSource));
+                        draft[sheetId][rowIndex]?.values?.splice(referenceColumnIndex, 0, ...newColumns);
+                    }
+                }
+                if (headerRow &&
+                    referenceColumnIndex >= range.startColumnIndex &&
+                    referenceColumnIndex <= range.endColumnIndex + numColumns) {
+                    const currentSheet = createSheetDraft(draft, sheetId, range.startRowIndex);
+                    const columnName = getNextTableColumnName(tableView.columns ?? undefined, generatedNames);
+                    const sheetCell = new SheetCell(sheetId, {
+                        rowIndex: range.startRowIndex,
+                        columnIndex: referenceColumnIndex,
+                    }, cloneCellWithFormatting(draft[sheetId]?.[range.startRowIndex]?.values?.[referenceColumnIndex]));
+                    sheetCell.setUserEnteredValue(columnName);
+                    currentSheet[range.startRowIndex].values[referenceColumnIndex] =
+                        sheetCell.getCellData();
+                }
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/insert-note.d.ts

@@ -0,0 +1,5 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CellData } from "@rowsncolumns/spreadsheet";
+import type { UseOnUpdateNoteProps } from "../hooks/use-on-update-note";
+export declare const insertNote: <T extends CellData>({ createHistory, locale, onChangeSheetData, }: UseOnUpdateNoteProps<T>) => (sheetId: number, { rowIndex, columnIndex }: CellInterface, note?: string) => void;
+//# sourceMappingURL=insert-note.d.ts.map

package/dist/esm/interface/insert-note.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-note.d.ts","sourceRoot":"","sources":["../../../interface/insert-note.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAI1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAGxE,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,QAAQ,EAAE,+CAI5C,oBAAoB,CAAC,CAAC,CAAC,MAEtB,SAAS,MAAM,EACf,2BAA2B,aAAa,EACxC,OAAO,MAAM,SA+BhB,CAAC"}

package/dist/esm/interface/insert-note.js

@@ -0,0 +1,23 @@
+import { produceWithPatches } from "immer";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export const insertNote = ({ createHistory, locale, onChangeSheetData, }) => {
+    return (sheetId, { rowIndex, columnIndex }, note) => {
+        const saveHistory = createHistory();
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                const cellData = currentSheet[rowIndex]?.values?.[columnIndex];
+                const sheetCell = new SheetCell(sheetId, { rowIndex, columnIndex }, cellData, { locale });
+                sheetCell.updateNote(note);
+                // Set cell data
+                currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};