@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/clear-formatting.js

@@ -0,0 +1,72 @@
+import { __read, __values } from "tslib";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export var clearFormatting = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, getDataValidationById = _a.getDataValidationById, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory;
+    return function (sheetId, activeCell, selections) {
+        var finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        var saveHistory = createHistory();
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_1, _a, e_2, _b;
+                var _c, _d;
+                // Create a cell
+                var sheetCell = new SheetCell();
+                try {
+                    for (var finalSelections_1 = __values(finalSelections), finalSelections_1_1 = finalSelections_1.next(); !finalSelections_1_1.done; finalSelections_1_1 = finalSelections_1.next()) {
+                        var sel = finalSelections_1_1.value;
+                        try {
+                            for (var _e = (e_2 = void 0, __values(iterateCellsInRange(sel.range))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                var _g = __read(_f.value, 2), rowIndex = _g[0], columnIndex = _g[1];
+                                var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                var cellData = (_d = (_c = currentSheet[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex];
+                                // Create a cell
+                                sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+                                // Set user entered format
+                                sheetCell.clearUserEnteredFormat();
+                                // Set cell data
+                                currentSheet[rowIndex].values[columnIndex] =
+                                    sheetCell.getCellData();
+                                // Register cellXfs
+                                cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.unRegister(sheetCell);
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (finalSelections_1_1 && !finalSelections_1_1.done && (_a = finalSelections_1.return)) _a.call(finalSelections_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches: inversePatches,
+                    patches: patches,
+                },
+                activeCell: { undo: activeCell, redo: activeCell },
+                selections: { undo: selections, redo: selections },
+                sheetId: { undo: sheetId, redo: undefined },
+            });
+            return nextState;
+        });
+        // Save cellXfs
+        cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getPatches(saveHistory);
+    };
+};

package/dist/cjs/interface/conditional-formatting-rules.d.ts

@@ -0,0 +1,7 @@
+import type { ConditionalFormatRule } from "@rowsncolumns/spreadsheet";
+import type { UseConditionalFormattingRulesProps } from "../hooks/use-conditional-formatting-rules";
+export declare const createConditionalFormattingRule: ({ enqueueCalculation, createHistory, onChangeConditionalFormats, }: UseConditionalFormattingRulesProps) => (rule: ConditionalFormatRule) => void;
+export declare const updateConditionalFormattingRule: ({ enqueueCalculation, createHistory, onChangeConditionalFormats, }: UseConditionalFormattingRulesProps) => (updatedRule: ConditionalFormatRule, previousRule: ConditionalFormatRule) => void;
+export declare const deleteConditionalFormattingRule: ({ enqueueCalculation, createHistory, onChangeConditionalFormats, }: UseConditionalFormattingRulesProps) => (rule: ConditionalFormatRule) => void;
+export declare const previewConditionalFormattingRule: ({ onChangeConditionalFormats, }: UseConditionalFormattingRulesProps) => (rule: ConditionalFormatRule) => void;
+//# sourceMappingURL=conditional-formatting-rules.d.ts.map

package/dist/cjs/interface/conditional-formatting-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-formatting-rules.d.ts","sourceRoot":"","sources":["../../../interface/conditional-formatting-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAMvE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,2CAA2C,CAAC;AAEpG,eAAO,MAAM,+BAA+B,GAAI,oEAI7C,kCAAkC,MAC3B,MAAM,qBAAqB,SAoCpC,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAAI,oEAI7C,kCAAkC,MAEjC,aAAa,qBAAqB,EAClC,cAAc,qBAAqB,SA8CtC,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAAI,oEAI7C,kCAAkC,MAC3B,MAAM,qBAAqB,SAuCpC,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAAI,iCAE9C,kCAAkC,MAC3B,MAAM,qBAAqB,SAcpC,CAAC"}

package/dist/cjs/interface/conditional-formatting-rules.js

@@ -0,0 +1,191 @@
+import { __read, __values } from "tslib";
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { isConditionalFormatFormulaRule } from "../api/conditional-format";
+import { dropXlsxSource } from "../api/xlsx-source";
+export var createConditionalFormattingRule = function (_a) {
+    var enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onChangeConditionalFormats = _a.onChangeConditionalFormats;
+    return function (rule) {
+        var saveHistory = createHistory();
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevConditionalFormats) {
+            var _a = __read(produceWithPatches(prevConditionalFormats, function (draft) {
+                var e_1, _a, e_2, _b;
+                draft.push(rule);
+                // Formula rule (include formula-backed rules too)
+                if (isConditionalFormatFormulaRule(rule)) {
+                    try {
+                        for (var _c = __values(rule.ranges), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var range = _d.value;
+                            try {
+                                for (var _e = (e_2 = void 0, __values(iterateCellsInRange(range))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                    var _g = __read(_f.value, 2), rowIndex = _g[0], columnIndex = _g[1];
+                                    enqueueCalculation({
+                                        type: "add",
+                                        position: {
+                                            rowIndex: rowIndex,
+                                            columnIndex: columnIndex,
+                                            sheetId: range.sheetId,
+                                            conditionalFormatId: rule.id,
+                                        },
+                                    });
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                conditionalFormats: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var updateConditionalFormattingRule = function (_a) {
+    var enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onChangeConditionalFormats = _a.onChangeConditionalFormats;
+    return function (updatedRule, previousRule) {
+        // Drop xlsxSource on the edited rule — the user's change makes the
+        // verbatim source-xlsx attrs stale, and the exporter would otherwise
+        // replay them instead of the user's new condition/formula/format.
+        var sanitizedRule = dropXlsxSource(updatedRule);
+        var saveHistory = createHistory();
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevConditionalFormats) {
+            var previousFormats = prevConditionalFormats.map(function (item) {
+                if (item.id === sanitizedRule.id) {
+                    return previousRule;
+                }
+                return item;
+            });
+            var _a = __read(produceWithPatches(previousFormats, function (draft) {
+                var e_3, _a, e_4, _b;
+                var idx = draft.findIndex(function (rule) { return rule.id === sanitizedRule.id; });
+                if (idx !== -1) {
+                    draft[idx] = sanitizedRule;
+                    try {
+                        for (var _c = __values(draft[idx].ranges), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var range = _d.value;
+                            try {
+                                for (var _e = (e_4 = void 0, __values(iterateCellsInRange(range))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                    var _g = __read(_f.value, 2), rowIndex = _g[0], columnIndex = _g[1];
+                                    enqueueCalculation({
+                                        type: "add",
+                                        position: {
+                                            rowIndex: rowIndex,
+                                            columnIndex: columnIndex,
+                                            sheetId: range.sheetId,
+                                            conditionalFormatId: sanitizedRule.id,
+                                        },
+                                    });
+                                }
+                            }
+                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                            finally {
+                                try {
+                                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                conditionalFormats: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var deleteConditionalFormattingRule = function (_a) {
+    var enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onChangeConditionalFormats = _a.onChangeConditionalFormats;
+    return function (rule) {
+        var saveHistory = createHistory();
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevConditionalFormats) {
+            var _a = __read(produceWithPatches(prevConditionalFormats, function (draft) {
+                var e_5, _a, e_6, _b;
+                var idx = draft.findIndex(function (cur) { return cur.id === rule.id; });
+                if (idx !== -1) {
+                    // Formula rule
+                    if (isConditionalFormatFormulaRule(draft[idx])) {
+                        try {
+                            for (var _c = __values(draft[idx].ranges), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                var range = _d.value;
+                                try {
+                                    for (var _e = (e_6 = void 0, __values(iterateCellsInRange(range))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                        var _g = __read(_f.value, 2), rowIndex = _g[0], columnIndex = _g[1];
+                                        enqueueCalculation({
+                                            type: "remove",
+                                            position: {
+                                                rowIndex: rowIndex,
+                                                columnIndex: columnIndex,
+                                                sheetId: range.sheetId,
+                                                conditionalFormatId: draft[idx].id,
+                                            },
+                                        });
+                                    }
+                                }
+                                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                                finally {
+                                    try {
+                                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                    }
+                                    finally { if (e_6) throw e_6.error; }
+                                }
+                            }
+                        }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                        finally {
+                            try {
+                                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                            }
+                            finally { if (e_5) throw e_5.error; }
+                        }
+                    }
+                    draft.splice(idx, 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                conditionalFormats: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var previewConditionalFormattingRule = function (_a) {
+    var onChangeConditionalFormats = _a.onChangeConditionalFormats;
+    return function (rule) {
+        // Preview is the user editing the rule live; drop xlsxSource so the
+        // exporter doesn't replay stale source attrs if a save happens mid-preview.
+        var sanitizedRule = dropXlsxSource(rule);
+        // Prevent undo redo
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prev) {
+            return prev.map(function (cur) {
+                if (cur.id === sanitizedRule.id) {
+                    return sanitizedRule;
+                }
+                return cur;
+            });
+        });
+    };
+};

package/dist/cjs/interface/create-table.d.ts

@@ -0,0 +1,5 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { BandedDefinition, CellData, SelectionAttributes, Sheet, TableTheme, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseOnTableProps } from "../hooks/use-on-table";
+export declare const createTable: <T extends CellData, S extends Sheet>({ locale, rowCount, columnCount, tables, basicFilter, theme: spreadsheetTheme, idCreationStrategy, enqueueCalculation, createHistory, onChangeSheets, onChangeTables, onChangeSheetData, getFormattedValue, getEffectiveValue, onRequestCalculate, getDependents, enqueueGraphOperation, getContentfulRangeAroundCell, generatedNames, }: UseOnTableProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], tableSpec?: Partial<TableView>, theme?: TableTheme, bandedRange?: BandedDefinition) => void;
+//# sourceMappingURL=create-table.d.ts.map

package/dist/cjs/interface/create-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-table.d.ts","sourceRoot":"","sources":["../../../interface/create-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAO/E,OAAO,KAAK,EACV,gBAAgB,EAChB,QAAQ,EAER,mBAAmB,EACnB,KAAK,EACL,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG7D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,0UAoB9D,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,MAEpB,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,YAAY,OAAO,CAAC,SAAS,CAAC,EAC9B,QAAQ,UAAU,EAClB,cAAc,gBAAgB,SAsIjC,CAAC"}

package/dist/cjs/interface/create-table.js

@@ -0,0 +1,96 @@
+import { __assign, __read } from "tslib";
+import { areaIntersects, isAreasEqual, isCellWithinBounds, selectionFromActiveCell, } from "@rowsncolumns/utils";
+import { uuid } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { getGeneratedTableName } from "../generated-names";
+import { getNextTableColumnName } from "../helpers";
+import { addTableColumn, tableWouldOverlap } from "./table-utils";
+export var createTable = function (_a) {
+    var locale = _a.locale, rowCount = _a.rowCount, columnCount = _a.columnCount, tables = _a.tables, basicFilter = _a.basicFilter, spreadsheetTheme = _a.theme, idCreationStrategy = _a.idCreationStrategy, enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeSheetData = _a.onChangeSheetData, getFormattedValue = _a.getFormattedValue, getEffectiveValue = _a.getEffectiveValue, onRequestCalculate = _a.onRequestCalculate, getDependents = _a.getDependents, enqueueGraphOperation = _a.enqueueGraphOperation, getContentfulRangeAroundCell = _a.getContentfulRangeAroundCell, generatedNames = _a.generatedNames;
+    return function (sheetId, activeCell, selections, tableSpec, theme, bandedRange) {
+        var _a;
+        // Validate
+        var lastSelection = selections === null || selections === void 0 ? void 0 : selections[selections.length - 1];
+        var saveHistory = createHistory();
+        var range = (tableSpec === null || tableSpec === void 0 ? void 0 : tableSpec.range)
+            ? tableSpec.range
+            : lastSelection
+                ? lastSelection.range
+                : (_a = getContentfulRangeAroundCell === null || getContentfulRangeAroundCell === void 0 ? void 0 : getContentfulRangeAroundCell(sheetId, activeCell)) !== null && _a !== void 0 ? _a : selectionFromActiveCell(activeCell)[0].range;
+        // Refuse to create a table whose rectangle overlaps an existing one on the
+        // same sheet — Excel rejects such workbooks on open.
+        if (tableWouldOverlap({ sheetId: sheetId, range: range }, tables)) {
+            return;
+        }
+        // Crate a table
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var _a, _b, _c;
+                var tableIndex = draft.findIndex(function (table) {
+                    return (isCellWithinBounds(activeCell, table.range) ||
+                        areaIntersects(table.range, lastSelection === null || lastSelection === void 0 ? void 0 : lastSelection.range)) &&
+                        table.sheetId === sheetId;
+                });
+                if (tableIndex === -1) {
+                    var columns = [];
+                    for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                        var formattedValue = getFormattedValue(sheetId, range.startRowIndex, columnIndex);
+                        var columnName = getNextTableColumnName(columns, generatedNames);
+                        columns.push({
+                            name: formattedValue || columnName,
+                        });
+                    }
+                    draft.push(__assign({ id: (_b = (_a = tableSpec === null || tableSpec === void 0 ? void 0 : tableSpec.id) !== null && _a !== void 0 ? _a : idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("table")) !== null && _b !== void 0 ? _b : uuid(), range: range, sheetId: sheetId, title: (_c = tableSpec === null || tableSpec === void 0 ? void 0 : tableSpec.title) !== null && _c !== void 0 ? _c : getGeneratedTableName(draft.length + 1, generatedNames), columns: columns, filterSpecs: [], headerRow: true, filterButton: true, sortSpecs: [], showRowStripes: true, bandedRange: bandedRange, theme: theme !== null && theme !== void 0 ? theme : "TableStyleLight1" }, tableSpec));
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Mark table cells as dirty
+            // Skip marking table as empty
+            // const recalcCells = markTableAsDirty(
+            //   sheetId,
+            //   range,
+            //   getDependents,
+            //   enqueueCalculation
+            // );
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                addTableColumn({
+                    draft: draft,
+                    getFormattedValue: getFormattedValue,
+                    sheetId: sheetId,
+                    range: range,
+                    locale: locale,
+                    generatedNames: generatedNames,
+                });
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Check if user is creating a table in basicFilter
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet && isAreasEqual((_a = sheet.basicFilter) === null || _a === void 0 ? void 0 : _a.range, range)) {
+                    sheet.basicFilter = undefined;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            if (patches.length) {
+                saveHistory({
+                    sheets: {
+                        patches: patches,
+                        inversePatches: inversePatches,
+                    },
+                });
+            }
+            return nextState;
+        });
+    };
+};

package/dist/cjs/interface/data-validation-rules.d.ts

@@ -0,0 +1,25 @@
+import { type CellData, type DataValidationRuleRecord } from "@rowsncolumns/spreadsheet";
+import type { UseDataValidationRuleProps } from "../hooks/use-data-validation-rules";
+export type CreateDataValidationRuleOptions = {
+    /**
+     * Skip the per-cell `enqueueCalculation` calls inside `updateRule` while
+     * still stamping the rule on each cell. The Excel import path uses this so
+     * formula-backed DV rules don't pin the calculator with thousands of
+     * off-viewport cells across inactive sheets; viewport-aware evaluation
+     * fires later via `use-calculation-initialize`.
+     */
+    skipEnqueue?: boolean;
+    importSource?: boolean;
+};
+export declare const createDataValidationRule: <T extends CellData>({ locale, onChangeSheetData, onChangeDataValidations, createHistory, enqueueCalculation, getEffectiveValuesFromRange, getSheetName, cellXfsRegistry, sharedStringRegistry, }: UseDataValidationRuleProps<T, any>) => (rule: DataValidationRuleRecord, options?: CreateDataValidationRuleOptions) => void;
+export declare const updateDataValidationRule: <T extends CellData>({ locale, onChangeSheetData, onChangeDataValidations, createHistory, enqueueCalculation, getEffectiveValuesFromRange, getSheetName, cellXfsRegistry, sharedStringRegistry, }: UseDataValidationRuleProps<T, any>) => (rule: DataValidationRuleRecord, previousRule: DataValidationRuleRecord) => void;
+export declare const deleteDataValidationRules: <T extends CellData>({ locale, onChangeSheetData, onChangeDataValidations, createHistory, enqueueCalculation, cellXfsRegistry, sharedStringRegistry, }: UseDataValidationRuleProps<T, any>) => (rules: DataValidationRuleRecord[]) => void;
+export declare const deleteDataValidationRule: <T extends CellData>({ locale, onChangeSheetData, onChangeDataValidations, createHistory, enqueueCalculation, cellXfsRegistry, sharedStringRegistry, }: UseDataValidationRuleProps<T, any>) => (rule: DataValidationRuleRecord) => void;
+/** 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 declare const DV_MATERIALIZE_RANGE_CELL_CAP = 20000;
+/** Upper bound on phantom cells materialized per `updateRule` call across all ranges. */
+export declare const DV_MATERIALIZE_CELL_BUDGET = 100000;
+//# sourceMappingURL=data-validation-rules.d.ts.map

package/dist/cjs/interface/data-validation-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-validation-rules.d.ts","sourceRoot":"","sources":["../../../interface/data-validation-rules.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,wBAAwB,EAC9B,MAAM,2BAA2B,CAAC;AAWnC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAKrF,MAAM,MAAM,+BAA+B,GAAG;IAC5C;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,QAAQ,EAAE,8KAU1D,0BAA0B,CAAC,CAAC,EAAE,GAAG,CAAC,MAEjC,MAAM,wBAAwB,EAC9B,UAAU,+BAA+B,SAgD5C,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,QAAQ,EAAE,8KAU1D,0BAA0B,CAAC,CAAC,EAAE,GAAG,CAAC,MAEjC,MAAM,wBAAwB,EAC9B,cAAc,wBAAwB,SAgEzC,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,CAAC,SAAS,QAAQ,EAAE,mIAQ3D,0BAA0B,CAAC,CAAC,EAAE,GAAG,CAAC,MAC3B,OAAO,wBAAwB,EAAE,SA6C1C,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,QAAQ,EAAE,mIAQ1D,0BAA0B,CAAC,CAAC,EAAE,GAAG,CAAC,MAC3B,MAAM,wBAAwB,SA+CvC,CAAC;AAEF;;;gEAGgE;AAChE,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAEpD,yFAAyF;AACzF,eAAO,MAAM,0BAA0B,SAAU,CAAC"}