@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/interface/data-validation-rules.js

@@ -0,0 +1,310 @@
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { isDataValidationFormulaRule } from "../api/data-validation";
+import { formulaToRelativeReference } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { dropXlsxSource } from "../api/xlsx-source";
+import { SheetCell } from "../sheet-cell";
+export const createDataValidationRule = ({ locale, onChangeSheetData, onChangeDataValidations, createHistory, enqueueCalculation, getEffectiveValuesFromRange, getSheetName, cellXfsRegistry, sharedStringRegistry, }) => {
+    return (rule, options) => {
+        const saveHistory = createHistory();
+        // Update record of validations
+        onChangeDataValidations?.((prev) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prev, (draft) => {
+                draft.push(rule);
+            });
+            saveHistory({
+                dataValidations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update cells
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // Add rule
+                updateRule(rule, draft, enqueueCalculation, locale, getEffectiveValuesFromRange, getSheetName, cellXfsRegistry, sharedStringRegistry, options?.skipEnqueue);
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const updateDataValidationRule = ({ locale, onChangeSheetData, onChangeDataValidations, createHistory, enqueueCalculation, getEffectiveValuesFromRange, getSheetName, cellXfsRegistry, sharedStringRegistry, }) => {
+    return (rule, previousRule) => {
+        // Drop xlsxSource — user edited the rule, so any captured source-xlsx
+        // attrs (type/operator/formula text) are stale and would override the
+        // current condition on export.
+        const sanitizedRule = dropXlsxSource(rule);
+        const saveHistory = createHistory();
+        // Update record of validations
+        onChangeDataValidations?.((prev) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prev, (draft) => {
+                const idx = draft.findIndex((cur) => cur.id === sanitizedRule.id);
+                if (idx !== -1) {
+                    draft[idx] = sanitizedRule;
+                }
+            });
+            saveHistory({
+                dataValidations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update cells
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // Remove old rule
+                removeRule(previousRule, draft, enqueueCalculation, locale, cellXfsRegistry, sharedStringRegistry);
+                // Add rule
+                updateRule(sanitizedRule, draft, enqueueCalculation, locale, getEffectiveValuesFromRange, getSheetName, cellXfsRegistry, sharedStringRegistry);
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const deleteDataValidationRules = ({ locale, onChangeSheetData, onChangeDataValidations, createHistory, enqueueCalculation, cellXfsRegistry, sharedStringRegistry, }) => {
+    return (rules) => {
+        const saveHistory = createHistory();
+        // Update local state
+        onChangeDataValidations?.((prev) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prev, (draft) => {
+                draft.length = 0;
+            });
+            saveHistory({
+                dataValidations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update cells
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                for (const rule of rules) {
+                    removeRule(rule, draft, enqueueCalculation, locale, cellXfsRegistry, sharedStringRegistry);
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const deleteDataValidationRule = ({ locale, onChangeSheetData, onChangeDataValidations, createHistory, enqueueCalculation, cellXfsRegistry, sharedStringRegistry, }) => {
+    return (rule) => {
+        const saveHistory = createHistory();
+        // Update state
+        onChangeDataValidations?.((prev) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prev, (draft) => {
+                const idx = draft.findIndex((cur) => cur.id === rule.id);
+                if (idx !== -1) {
+                    draft.splice(idx, 1);
+                }
+            });
+            saveHistory({
+                dataValidations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        // Update cells
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // Remove rule
+                removeRule(rule, draft, enqueueCalculation, locale, cellXfsRegistry, sharedStringRegistry);
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+/** A cell is only materialized (created solely to carry the rule stamp) for ranges up to this
+ * many cells — whole-column/row sqrefs would otherwise stamp ~1M phantom cells, rendering
+ * dropdown arrows on a million empty rows. Cells that exist anyway are stamped regardless of
+ * range size. Mirrors the toolkit's `dv-cell-stamp.ts` caps. */
+export const DV_MATERIALIZE_RANGE_CELL_CAP = 20_000;
+/** Upper bound on phantom cells materialized per `updateRule` call across all ranges. */
+export const DV_MATERIALIZE_CELL_BUDGET = 100_000;
+/**
+ * Helper function to update a rule
+ * @param rule
+ * @param draft
+ * @param enqueueCalculation
+ * @param sheetId
+ * @param locale
+ */
+function updateRule(rule, draft, enqueueCalculation, locale, getRangeValues, getSheetName, cellXfsRegistry, sharedStringRegistry, skipEnqueue) {
+    // Create a cell
+    const sheetCell = new SheetCell();
+    // Update cells
+    if (rule.ranges.length) {
+        const masterCell = {
+            rowIndex: rule.ranges[0].startRowIndex,
+            columnIndex: rule.ranges[0].startColumnIndex,
+        };
+        const activeSheetName = getSheetName?.(rule.ranges[0].sheetId) ?? "";
+        let materializeBudget = DV_MATERIALIZE_CELL_BUDGET;
+        const stampCell = (sheetId, rowIndex, columnIndex) => {
+            const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+            const cellData = currentSheet[rowIndex].values?.[columnIndex];
+            sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                getRangeValues,
+                locale,
+                cellXfsRegistry,
+                sharedStringRegistry,
+            });
+            const ruleWithRelativeFormula = {
+                ...rule,
+                condition: rule.condition
+                    ? {
+                        ...rule.condition,
+                        values: rule.condition?.values?.map((value) => {
+                            if (isDataValidationFormulaRule(rule)) {
+                                return {
+                                    userEnteredValue: formulaToRelativeReference(value.userEnteredValue, masterCell, { rowIndex, columnIndex }, activeSheetName, {
+                                        ignoreCircular: true,
+                                        ignoreReferenceError: true,
+                                    }) ?? "",
+                                };
+                            }
+                            return value;
+                        }),
+                    }
+                    : undefined,
+            };
+            sheetCell.setDataValidation(rule.id, ruleWithRelativeFormula);
+            // Validate rule
+            sheetCell.validate();
+            // Set cell data
+            currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            // Formula rule
+            if (isDataValidationFormulaRule(rule) && !skipEnqueue) {
+                enqueueCalculation({
+                    type: "add",
+                    position: {
+                        rowIndex,
+                        columnIndex,
+                        sheetId,
+                        dataValidationId: rule.id,
+                    },
+                });
+            }
+        };
+        for (const range of rule.ranges) {
+            const cellCount = (range.endRowIndex - range.startRowIndex + 1) *
+                (range.endColumnIndex - range.startColumnIndex + 1);
+            if (Number.isFinite(cellCount) &&
+                cellCount <= DV_MATERIALIZE_RANGE_CELL_CAP) {
+                for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                    const exists = draft[range.sheetId]?.[rowIndex]?.values?.[columnIndex] != null;
+                    if (!exists) {
+                        // Materializing an absent cell just to carry the stamp — budget-capped.
+                        if (materializeBudget <= 0)
+                            continue;
+                        materializeBudget--;
+                    }
+                    stampCell(range.sheetId, rowIndex, columnIndex);
+                }
+            }
+            else {
+                // Whole-column/row (or otherwise huge) range: stamp only cells that already exist.
+                // Materializing every covered cell minted ~1M phantom cells with dropdown arrows on
+                // blank rows (imported-template regression). Beyond-cap blank cells carry no stamp —
+                // matching the source file, where those cells didn't exist either.
+                const currentSheet = draft[range.sheetId];
+                if (!currentSheet)
+                    continue;
+                const maxRow = Math.min(range.endRowIndex, currentSheet.length - 1);
+                for (let rowIndex = Math.max(range.startRowIndex, 0); rowIndex <= maxRow; rowIndex++) {
+                    const values = currentSheet[rowIndex]?.values;
+                    if (!values)
+                        continue;
+                    const maxCol = Math.min(range.endColumnIndex, values.length - 1);
+                    for (let columnIndex = Math.max(range.startColumnIndex, 0); columnIndex <= maxCol; columnIndex++) {
+                        if (values[columnIndex] == null)
+                            continue;
+                        stampCell(range.sheetId, rowIndex, columnIndex);
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * Helper function to remove a rule
+ * @param rule
+ * @param draft
+ * @param enqueueCalculation
+ * @param sheetId
+ * @param locale
+ */
+function removeRule(rule, draft, enqueueCalculation, locale, cellXfsRegistry, sharedStringRegistry) {
+    // Create a cell
+    const sheetCell = new SheetCell();
+    const unstampCell = (sheetId, rowIndex, columnIndex) => {
+        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+        const cellData = currentSheet[rowIndex].values?.[columnIndex];
+        sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+            locale,
+            cellXfsRegistry,
+            sharedStringRegistry,
+        });
+        // Remove data validation
+        sheetCell.deleteDataValidation();
+        // Set cell data
+        currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+        if (isDataValidationFormulaRule(rule)) {
+            // Remove cell
+            enqueueCalculation({
+                type: "remove",
+                position: {
+                    rowIndex,
+                    columnIndex,
+                    sheetId,
+                    dataValidationId: rule.id,
+                },
+            });
+        }
+    };
+    // Update cells
+    if (rule.ranges.length) {
+        for (const range of rule.ranges) {
+            const cellCount = (range.endRowIndex - range.startRowIndex + 1) *
+                (range.endColumnIndex - range.startColumnIndex + 1);
+            if (Number.isFinite(cellCount) &&
+                cellCount <= DV_MATERIALIZE_RANGE_CELL_CAP) {
+                for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                    unstampCell(range.sheetId, rowIndex, columnIndex);
+                }
+            }
+            else {
+                // Whole-column/row range: only existing cells can carry a stamp — visiting every
+                // covered coordinate would materialize ~1M rows just to delete nothing.
+                const currentSheet = draft[range.sheetId];
+                if (!currentSheet)
+                    continue;
+                const maxRow = Math.min(range.endRowIndex, currentSheet.length - 1);
+                for (let rowIndex = Math.max(range.startRowIndex, 0); rowIndex <= maxRow; rowIndex++) {
+                    const values = currentSheet[rowIndex]?.values;
+                    if (!values)
+                        continue;
+                    const maxCol = Math.min(range.endColumnIndex, values.length - 1);
+                    for (let columnIndex = Math.max(range.startColumnIndex, 0); columnIndex <= maxCol; columnIndex++) {
+                        if (values[columnIndex] == null)
+                            continue;
+                        unstampCell(range.sheetId, rowIndex, columnIndex);
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/esm/interface/data-validation-utils.d.ts

@@ -0,0 +1,12 @@
+import type { CellData, DataValidationRuleRecord } from "@rowsncolumns/spreadsheet";
+import type React from "react";
+import type { SpreadsheetPatch } from "../hooks/use-undo-redo";
+export type DataValidationTarget = {
+    sheetId: number;
+    rowIndex: number;
+    columnIndex: number;
+};
+export type DataValidationTargetMap = Map<DataValidationRuleRecord["id"], DataValidationTarget[]>;
+export declare const collectDataValidationTarget: (targets: DataValidationTargetMap, sheetId: number, rowIndex: number, columnIndex: number, cellData?: CellData | null | undefined) => void;
+export declare const extendDataValidationRanges: (targets: DataValidationTargetMap, onChangeDataValidations?: React.Dispatch<React.SetStateAction<DataValidationRuleRecord[]>>, saveHistory?: (patches: SpreadsheetPatch) => void) => void;
+//# sourceMappingURL=data-validation-utils.d.ts.map

package/dist/esm/interface/data-validation-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-validation-utils.d.ts","sourceRoot":"","sources":["../../../interface/data-validation-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,wBAAwB,EACzB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,GAAG,CACvC,wBAAwB,CAAC,IAAI,CAAC,EAC9B,oBAAoB,EAAE,CACvB,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,SAAS,uBAAuB,EAChC,SAAS,MAAM,EACf,UAAU,MAAM,EAChB,aAAa,MAAM,EACnB,WAAW,QAAQ,GAAG,IAAI,GAAG,SAAS,SAsBvC,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,SAAS,uBAAuB,EAChC,0BAA0B,KAAK,CAAC,QAAQ,CACtC,KAAK,CAAC,cAAc,CAAC,wBAAwB,EAAE,CAAC,CACjD,EACD,cAAc,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,SAgFlD,CAAC"}

package/dist/esm/interface/data-validation-utils.js

@@ -0,0 +1,79 @@
+import { produceWithPatches } from "immer";
+export const collectDataValidationTarget = (targets, sheetId, rowIndex, columnIndex, cellData) => {
+    const validationId = cellData?.dataValidation;
+    if (validationId === undefined ||
+        validationId === null ||
+        (typeof validationId !== "number" && typeof validationId !== "string")) {
+        return;
+    }
+    const list = targets.get(validationId) ?? [];
+    const exists = list.some((pos) => pos.sheetId === sheetId &&
+        pos.rowIndex === rowIndex &&
+        pos.columnIndex === columnIndex);
+    if (!exists) {
+        list.push({ sheetId, rowIndex, columnIndex });
+        targets.set(validationId, list);
+    }
+};
+export const extendDataValidationRanges = (targets, onChangeDataValidations, saveHistory) => {
+    if (!targets.size || !onChangeDataValidations) {
+        return;
+    }
+    onChangeDataValidations((prev) => {
+        const [nextState, patches, inversePatches] = produceWithPatches(prev, (draft) => {
+            for (const [validationId, positions] of targets) {
+                const idx = draft.findIndex((rule) => rule.id === validationId);
+                if (idx === -1)
+                    continue;
+                const rule = draft[idx];
+                if (!rule.ranges)
+                    rule.ranges = [];
+                for (const { sheetId, rowIndex, columnIndex } of positions) {
+                    let extended = false;
+                    for (const range of rule.ranges) {
+                        if (range.sheetId !== sheetId)
+                            continue;
+                        const contains = range.startRowIndex <= rowIndex &&
+                            range.endRowIndex >= rowIndex &&
+                            range.startColumnIndex <= columnIndex &&
+                            range.endColumnIndex >= columnIndex;
+                        const sameRowBand = range.startRowIndex <= rowIndex &&
+                            range.endRowIndex >= rowIndex &&
+                            (range.startColumnIndex === columnIndex + 1 ||
+                                range.endColumnIndex === columnIndex - 1);
+                        const sameColumnBand = range.startColumnIndex <= columnIndex &&
+                            range.endColumnIndex >= columnIndex &&
+                            (range.startRowIndex === rowIndex + 1 ||
+                                range.endRowIndex === rowIndex - 1);
+                        if (contains || sameRowBand || sameColumnBand) {
+                            range.startRowIndex = Math.min(range.startRowIndex, rowIndex);
+                            range.endRowIndex = Math.max(range.endRowIndex, rowIndex);
+                            range.startColumnIndex = Math.min(range.startColumnIndex, columnIndex);
+                            range.endColumnIndex = Math.max(range.endColumnIndex, columnIndex);
+                            extended = true;
+                            break;
+                        }
+                    }
+                    if (!extended) {
+                        rule.ranges.push({
+                            sheetId,
+                            startRowIndex: rowIndex,
+                            endRowIndex: rowIndex,
+                            startColumnIndex: columnIndex,
+                            endColumnIndex: columnIndex,
+                        });
+                    }
+                }
+            }
+        });
+        if (saveHistory) {
+            saveHistory({
+                dataValidations: {
+                    patches,
+                    inversePatches,
+                },
+            });
+        }
+        return nextState;
+    });
+};

package/dist/esm/interface/delete-cells-shift-left.d.ts

@@ -0,0 +1,5 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnDeleteCellsShiftLeftProps } from "../hooks/use-on-delete-cells-shift-left";
+export declare const deleteCellsShiftLeft: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }: UseOnDeleteCellsShiftLeftProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+//# sourceMappingURL=delete-cells-shift-left.d.ts.map

package/dist/esm/interface/delete-cells-shift-left.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-cells-shift-left.d.ts","sourceRoot":"","sources":["../../../interface/delete-cells-shift-left.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EACV,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AAQnC,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AAG9F,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,gQAgBvE,8BAA8B,CAAC,CAAC,EAAE,CAAC,CAAC,MAEnC,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAkMnD,CAAC"}

package/dist/esm/interface/delete-cells-shift-left.js

@@ -0,0 +1,146 @@
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
+import { moveMergedCells } from "../api/merges";
+export const deleteCellsShiftLeft = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }) => {
+    return (sheetId, activeCell, selections) => {
+        const saveHistory = createHistory();
+        const recalcCells = new Map();
+        // Calculate selection
+        const finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        const selection = finalSelections[finalSelections.length - 1];
+        const count = selection.range.endColumnIndex - selection.range.startColumnIndex + 1;
+        enqueueStructureChange?.({
+            kind: "delete-cells-shift-left",
+            sheetId,
+            startRowIndex: selection.range.startRowIndex,
+            endRowIndex: selection.range.endRowIndex,
+            startColumnIndex: selection.range.startColumnIndex,
+            endColumnIndex: selection.range.endColumnIndex,
+            columnCount,
+        });
+        // Update merges on sheet
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((s) => s.sheetId === sheetId);
+                if (sheet?.merges) {
+                    for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                        sheet.merges = moveMergedCells(sheet.merges, "column-remove", columnIndex);
+                    }
+                }
+            });
+            saveHistory({ sheets: { patches, inversePatches } });
+            return nextState;
+        });
+        // Update citations - delete if overlapping, shift back if after
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                const deleteRowStart = selection.range.startRowIndex;
+                const deleteRowEnd = selection.range.endRowIndex;
+                const deleteColStart = selection.range.startColumnIndex;
+                const deleteColEnd = selection.range.endColumnIndex;
+                const shiftAmount = deleteColEnd - deleteColStart + 1;
+                for (let idx = draft.length - 1; idx >= 0; idx--) {
+                    const citation = draft[idx];
+                    if (citation.range.sheetId !== sheetId)
+                        continue;
+                    const rowsOverlap = !(citation.range.endRowIndex < deleteRowStart || citation.range.startRowIndex > deleteRowEnd);
+                    if (rowsOverlap) {
+                        const colsOverlap = !(citation.range.endColumnIndex < deleteColStart || citation.range.startColumnIndex > deleteColEnd);
+                        if (colsOverlap) {
+                            draft.splice(idx, 1);
+                        }
+                        else if (citation.range.startColumnIndex > deleteColEnd) {
+                            citation.range.startColumnIndex -= shiftAmount;
+                            citation.range.endColumnIndex -= shiftAmount;
+                        }
+                    }
+                }
+            });
+            saveHistory({ citations: { patches, inversePatches } });
+            return nextState;
+        });
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const movedKeys = new Set();
+                // Build a broad source range across the selection rows, clamped per row by helper
+                const sourceRange = {
+                    startRowIndex: selection.range.startRowIndex,
+                    endRowIndex: selection.range.endRowIndex,
+                    startColumnIndex: selection.range.startColumnIndex,
+                    endColumnIndex: columnCount,
+                };
+                // Collect unique dependents only once
+                const dependents = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange,
+                    getDependents,
+                });
+                // Move each dependent exactly once (shift left by count)
+                for (const pos of dependents.values()) {
+                    moveFormulaAtPosition({
+                        draft,
+                        position: pos,
+                        enqueueCalculation,
+                        enqueueGraphOperation,
+                        recalcCells,
+                        movedKeys,
+                        rowDelta: 0,
+                        columnDelta: -count,
+                        sourceRange,
+                        locale,
+                        rowCount,
+                        columnCount,
+                        cellXfsRegistry,
+                        sharedStringRegistry,
+                    });
+                }
+                // Also adjust formulas that live within the selection band itself
+                for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                    const dataColumnCount = draft[sheetId]?.[rowIndex]?.values?.length ?? 0;
+                    const startCol = Math.min(Math.max(selection.range.startColumnIndex, 1), dataColumnCount);
+                    for (let columnIndex = startCol; columnIndex < dataColumnCount; columnIndex++) {
+                        moveFormulaAtPosition({
+                            draft,
+                            position: { sheetId, rowIndex, columnIndex },
+                            enqueueCalculation,
+                            enqueueGraphOperation,
+                            recalcCells,
+                            movedKeys,
+                            rowDelta: 0,
+                            columnDelta: -count,
+                            sourceRange,
+                            locale,
+                            rowCount,
+                            columnCount,
+                            cellXfsRegistry,
+                            sharedStringRegistry,
+                        });
+                    }
+                }
+                // Finally delete the selected cells by splicing from right to left
+                for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                    for (let columnIndex = selection.range.endColumnIndex; columnIndex >= selection.range.startColumnIndex; columnIndex--) {
+                        if (draft[sheetId]?.[rowIndex]?.values) {
+                            draft[sheetId][rowIndex]?.values?.splice(columnIndex, 1);
+                        }
+                    }
+                }
+            });
+            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/delete-cells-shift-up.d.ts

@@ -0,0 +1,5 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnDeleteCellsShiftUpProps } from "../hooks/use-on-delete-cells-shift-up";
+export declare const deleteCellsShiftUp: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }: UseOnDeleteCellsShiftUpProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+//# sourceMappingURL=delete-cells-shift-up.d.ts.map

package/dist/esm/interface/delete-cells-shift-up.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-cells-shift-up.d.ts","sourceRoot":"","sources":["../../../interface/delete-cells-shift-up.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EACV,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AASnC,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAG1F,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,gQAgBrE,4BAA4B,CAAC,CAAC,EAAE,CAAC,CAAC,MAEjC,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAuKnD,CAAC"}