@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,366 @@
+import { __assign, __read, __values } from "tslib";
+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 var createDataValidationRule = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, onChangeDataValidations = _a.onChangeDataValidations, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, getEffectiveValuesFromRange = _a.getEffectiveValuesFromRange, getSheetName = _a.getSheetName, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
+    return function (rule, options) {
+        var saveHistory = createHistory();
+        // Update record of validations
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prev) {
+            var _a = __read(produceWithPatches(prev, function (draft) {
+                draft.push(rule);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                dataValidations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update cells
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                // Add rule
+                updateRule(rule, draft, enqueueCalculation, locale, getEffectiveValuesFromRange, getSheetName, cellXfsRegistry, sharedStringRegistry, options === null || options === void 0 ? void 0 : options.skipEnqueue);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var updateDataValidationRule = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, onChangeDataValidations = _a.onChangeDataValidations, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, getEffectiveValuesFromRange = _a.getEffectiveValuesFromRange, getSheetName = _a.getSheetName, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
+    return function (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.
+        var sanitizedRule = dropXlsxSource(rule);
+        var saveHistory = createHistory();
+        // Update record of validations
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prev) {
+            var _a = __read(produceWithPatches(prev, function (draft) {
+                var idx = draft.findIndex(function (cur) { return cur.id === sanitizedRule.id; });
+                if (idx !== -1) {
+                    draft[idx] = sanitizedRule;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                dataValidations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update cells
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                // Remove old rule
+                removeRule(previousRule, draft, enqueueCalculation, locale, cellXfsRegistry, sharedStringRegistry);
+                // Add rule
+                updateRule(sanitizedRule, draft, enqueueCalculation, locale, getEffectiveValuesFromRange, getSheetName, cellXfsRegistry, sharedStringRegistry);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var deleteDataValidationRules = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, onChangeDataValidations = _a.onChangeDataValidations, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
+    return function (rules) {
+        var saveHistory = createHistory();
+        // Update local state
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prev) {
+            var _a = __read(produceWithPatches(prev, function (draft) {
+                draft.length = 0;
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                dataValidations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update cells
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_1, _a;
+                try {
+                    for (var rules_1 = __values(rules), rules_1_1 = rules_1.next(); !rules_1_1.done; rules_1_1 = rules_1.next()) {
+                        var rule = rules_1_1.value;
+                        removeRule(rule, draft, enqueueCalculation, locale, cellXfsRegistry, sharedStringRegistry);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (rules_1_1 && !rules_1_1.done && (_a = rules_1.return)) _a.call(rules_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var deleteDataValidationRule = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, onChangeDataValidations = _a.onChangeDataValidations, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
+    return function (rule) {
+        var saveHistory = createHistory();
+        // Update state
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prev) {
+            var _a = __read(produceWithPatches(prev, function (draft) {
+                var idx = draft.findIndex(function (cur) { return cur.id === rule.id; });
+                if (idx !== -1) {
+                    draft.splice(idx, 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                dataValidations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        // Update cells
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                // Remove rule
+                removeRule(rule, draft, enqueueCalculation, locale, cellXfsRegistry, sharedStringRegistry);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: 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 var DV_MATERIALIZE_RANGE_CELL_CAP = 20000;
+/** Upper bound on phantom cells materialized per `updateRule` call across all ranges. */
+export var DV_MATERIALIZE_CELL_BUDGET = 100000;
+/**
+ * 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) {
+    var e_2, _a, e_3, _b;
+    var _c, _d, _e, _f, _g;
+    // Create a cell
+    var sheetCell = new SheetCell();
+    // Update cells
+    if (rule.ranges.length) {
+        var masterCell_1 = {
+            rowIndex: rule.ranges[0].startRowIndex,
+            columnIndex: rule.ranges[0].startColumnIndex,
+        };
+        var activeSheetName_1 = (_c = getSheetName === null || getSheetName === void 0 ? void 0 : getSheetName(rule.ranges[0].sheetId)) !== null && _c !== void 0 ? _c : "";
+        var materializeBudget = DV_MATERIALIZE_CELL_BUDGET;
+        var stampCell = function (sheetId, rowIndex, columnIndex) {
+            var _a, _b, _c;
+            var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+            var cellData = (_a = currentSheet[rowIndex].values) === null || _a === void 0 ? void 0 : _a[columnIndex];
+            sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                getRangeValues: getRangeValues,
+                locale: locale,
+                cellXfsRegistry: cellXfsRegistry,
+                sharedStringRegistry: sharedStringRegistry,
+            });
+            var ruleWithRelativeFormula = __assign(__assign({}, rule), { condition: rule.condition
+                    ? __assign(__assign({}, rule.condition), { values: (_c = (_b = rule.condition) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c.map(function (value) {
+                            var _a;
+                            if (isDataValidationFormulaRule(rule)) {
+                                return {
+                                    userEnteredValue: (_a = formulaToRelativeReference(value.userEnteredValue, masterCell_1, { rowIndex: rowIndex, columnIndex: columnIndex }, activeSheetName_1, {
+                                        ignoreCircular: true,
+                                        ignoreReferenceError: true,
+                                    })) !== null && _a !== void 0 ? _a : "",
+                                };
+                            }
+                            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: rowIndex,
+                        columnIndex: columnIndex,
+                        sheetId: sheetId,
+                        dataValidationId: rule.id,
+                    },
+                });
+            }
+        };
+        try {
+            for (var _h = __values(rule.ranges), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var range = _j.value;
+                var cellCount = (range.endRowIndex - range.startRowIndex + 1) *
+                    (range.endColumnIndex - range.startColumnIndex + 1);
+                if (Number.isFinite(cellCount) &&
+                    cellCount <= DV_MATERIALIZE_RANGE_CELL_CAP) {
+                    try {
+                        for (var _k = (e_3 = void 0, __values(iterateCellsInRange(range))), _l = _k.next(); !_l.done; _l = _k.next()) {
+                            var _m = __read(_l.value, 2), rowIndex = _m[0], columnIndex = _m[1];
+                            var exists = ((_f = (_e = (_d = draft[range.sheetId]) === null || _d === void 0 ? void 0 : _d[rowIndex]) === null || _e === void 0 ? void 0 : _e.values) === null || _f === void 0 ? void 0 : _f[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);
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_l && !_l.done && (_b = _k.return)) _b.call(_k);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+                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.
+                    var currentSheet = draft[range.sheetId];
+                    if (!currentSheet)
+                        continue;
+                    var maxRow = Math.min(range.endRowIndex, currentSheet.length - 1);
+                    for (var rowIndex = Math.max(range.startRowIndex, 0); rowIndex <= maxRow; rowIndex++) {
+                        var values = (_g = currentSheet[rowIndex]) === null || _g === void 0 ? void 0 : _g.values;
+                        if (!values)
+                            continue;
+                        var maxCol = Math.min(range.endColumnIndex, values.length - 1);
+                        for (var columnIndex = Math.max(range.startColumnIndex, 0); columnIndex <= maxCol; columnIndex++) {
+                            if (values[columnIndex] == null)
+                                continue;
+                            stampCell(range.sheetId, rowIndex, columnIndex);
+                        }
+                    }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+}
+/**
+ * Helper function to remove a rule
+ * @param rule
+ * @param draft
+ * @param enqueueCalculation
+ * @param sheetId
+ * @param locale
+ */
+function removeRule(rule, draft, enqueueCalculation, locale, cellXfsRegistry, sharedStringRegistry) {
+    var e_4, _a, e_5, _b;
+    var _c;
+    // Create a cell
+    var sheetCell = new SheetCell();
+    var unstampCell = function (sheetId, rowIndex, columnIndex) {
+        var _a;
+        var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+        var cellData = (_a = currentSheet[rowIndex].values) === null || _a === void 0 ? void 0 : _a[columnIndex];
+        sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+            locale: locale,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: 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: rowIndex,
+                    columnIndex: columnIndex,
+                    sheetId: sheetId,
+                    dataValidationId: rule.id,
+                },
+            });
+        }
+    };
+    // Update cells
+    if (rule.ranges.length) {
+        try {
+            for (var _d = __values(rule.ranges), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var range = _e.value;
+                var cellCount = (range.endRowIndex - range.startRowIndex + 1) *
+                    (range.endColumnIndex - range.startColumnIndex + 1);
+                if (Number.isFinite(cellCount) &&
+                    cellCount <= DV_MATERIALIZE_RANGE_CELL_CAP) {
+                    try {
+                        for (var _f = (e_5 = void 0, __values(iterateCellsInRange(range))), _g = _f.next(); !_g.done; _g = _f.next()) {
+                            var _h = __read(_g.value, 2), rowIndex = _h[0], columnIndex = _h[1];
+                            unstampCell(range.sheetId, rowIndex, columnIndex);
+                        }
+                    }
+                    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; }
+                    }
+                }
+                else {
+                    // Whole-column/row range: only existing cells can carry a stamp — visiting every
+                    // covered coordinate would materialize ~1M rows just to delete nothing.
+                    var currentSheet = draft[range.sheetId];
+                    if (!currentSheet)
+                        continue;
+                    var maxRow = Math.min(range.endRowIndex, currentSheet.length - 1);
+                    for (var rowIndex = Math.max(range.startRowIndex, 0); rowIndex <= maxRow; rowIndex++) {
+                        var values = (_c = currentSheet[rowIndex]) === null || _c === void 0 ? void 0 : _c.values;
+                        if (!values)
+                            continue;
+                        var maxCol = Math.min(range.endColumnIndex, values.length - 1);
+                        for (var columnIndex = Math.max(range.startColumnIndex, 0); columnIndex <= maxCol; columnIndex++) {
+                            if (values[columnIndex] == null)
+                                continue;
+                            unstampCell(range.sheetId, rowIndex, columnIndex);
+                        }
+                    }
+                }
+            }
+        }
+        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; }
+        }
+    }
+}

package/dist/cjs/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/cjs/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/cjs/interface/data-validation-utils.js

@@ -0,0 +1,118 @@
+import { __read, __values } from "tslib";
+import { produceWithPatches } from "immer";
+export var collectDataValidationTarget = function (targets, sheetId, rowIndex, columnIndex, cellData) {
+    var _a;
+    var validationId = cellData === null || cellData === void 0 ? void 0 : cellData.dataValidation;
+    if (validationId === undefined ||
+        validationId === null ||
+        (typeof validationId !== "number" && typeof validationId !== "string")) {
+        return;
+    }
+    var list = (_a = targets.get(validationId)) !== null && _a !== void 0 ? _a : [];
+    var exists = list.some(function (pos) {
+        return pos.sheetId === sheetId &&
+            pos.rowIndex === rowIndex &&
+            pos.columnIndex === columnIndex;
+    });
+    if (!exists) {
+        list.push({ sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex });
+        targets.set(validationId, list);
+    }
+};
+export var extendDataValidationRanges = function (targets, onChangeDataValidations, saveHistory) {
+    if (!targets.size || !onChangeDataValidations) {
+        return;
+    }
+    onChangeDataValidations(function (prev) {
+        var _a = __read(produceWithPatches(prev, function (draft) {
+            var e_1, _a;
+            var _loop_1 = function (validationId, positions) {
+                var e_2, _c, e_3, _d;
+                var idx = draft.findIndex(function (rule) { return rule.id === validationId; });
+                if (idx === -1)
+                    return "continue";
+                var rule = draft[idx];
+                if (!rule.ranges)
+                    rule.ranges = [];
+                try {
+                    for (var positions_1 = (e_2 = void 0, __values(positions)), positions_1_1 = positions_1.next(); !positions_1_1.done; positions_1_1 = positions_1.next()) {
+                        var _e = positions_1_1.value, sheetId = _e.sheetId, rowIndex = _e.rowIndex, columnIndex = _e.columnIndex;
+                        var extended = false;
+                        try {
+                            for (var _f = (e_3 = void 0, __values(rule.ranges)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                var range = _g.value;
+                                if (range.sheetId !== sheetId)
+                                    continue;
+                                var contains = range.startRowIndex <= rowIndex &&
+                                    range.endRowIndex >= rowIndex &&
+                                    range.startColumnIndex <= columnIndex &&
+                                    range.endColumnIndex >= columnIndex;
+                                var sameRowBand = range.startRowIndex <= rowIndex &&
+                                    range.endRowIndex >= rowIndex &&
+                                    (range.startColumnIndex === columnIndex + 1 ||
+                                        range.endColumnIndex === columnIndex - 1);
+                                var 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;
+                                }
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (_g && !_g.done && (_d = _f.return)) _d.call(_f);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                        if (!extended) {
+                            rule.ranges.push({
+                                sheetId: sheetId,
+                                startRowIndex: rowIndex,
+                                endRowIndex: rowIndex,
+                                startColumnIndex: columnIndex,
+                                endColumnIndex: columnIndex,
+                            });
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (positions_1_1 && !positions_1_1.done && (_c = positions_1.return)) _c.call(positions_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            };
+            try {
+                for (var targets_1 = __values(targets), targets_1_1 = targets_1.next(); !targets_1_1.done; targets_1_1 = targets_1.next()) {
+                    var _b = __read(targets_1_1.value, 2), validationId = _b[0], positions = _b[1];
+                    _loop_1(validationId, positions);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (targets_1_1 && !targets_1_1.done && (_a = targets_1.return)) _a.call(targets_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+        if (saveHistory) {
+            saveHistory({
+                dataValidations: {
+                    patches: patches,
+                    inversePatches: inversePatches,
+                },
+            });
+        }
+        return nextState;
+    });
+};

package/dist/cjs/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/cjs/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"}