@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/interface/chart-extensions.js

@@ -0,0 +1,71 @@
+import { enablePatches } from "immer";
+enablePatches();
+// Chart function imports with fallbacks
+let createChart = null;
+let deleteChart = null;
+let moveChart = null;
+let resizeChart = null;
+let updateChart = null;
+try {
+    // Try to import chart interface functions only (server-safe path).
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    createChart =
+        require("@rowsncolumns/charts/interface/create-chart").createChart;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    deleteChart =
+        require("@rowsncolumns/charts/interface/delete-chart").deleteChart;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    moveChart = require("@rowsncolumns/charts/interface/move-chart").moveChart;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    resizeChart =
+        require("@rowsncolumns/charts/interface/resize-chart").resizeChart;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    updateChart =
+        require("@rowsncolumns/charts/interface/update-chart").updateChart;
+}
+catch {
+    // Charts package not available - functions will remain null
+}
+// Helper function to check if charts are available
+export const isChartsAvailable = () => {
+    return (createChart !== null &&
+        deleteChart !== null &&
+        moveChart !== null &&
+        resizeChart !== null &&
+        updateChart !== null);
+};
+// Helper function to throw error when charts are not available
+const throwChartsNotAvailable = (operation) => {
+    throw new Error(`Chart ${operation} operation requires the @rowsncolumns/charts package to be installed. Please install it with: npm install @rowsncolumns/charts`);
+};
+// Exported chart functions with availability checks
+export const safeCreateChart = (props) => {
+    if (!createChart) {
+        throwChartsNotAvailable("create");
+    }
+    return createChart(props);
+};
+export const safeDeleteChart = (props) => {
+    if (!deleteChart) {
+        throwChartsNotAvailable("delete");
+    }
+    return deleteChart(props);
+};
+export const safeMoveChart = (props) => {
+    if (!moveChart) {
+        throwChartsNotAvailable("move");
+    }
+    return moveChart(props);
+};
+export const safeResizeChart = (props) => {
+    if (!resizeChart) {
+        throwChartsNotAvailable("resize");
+    }
+    return resizeChart(props);
+};
+export const safeUpdateChart = (props) => {
+    if (!updateChart) {
+        throwChartsNotAvailable("update");
+    }
+    return updateChart(props);
+};

package/dist/esm/interface/citations.d.ts

@@ -0,0 +1,33 @@
+import type { Citation } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseSpreadsheetProps } from "../hooks/use-spreadsheet-state";
+import type { SpreadsheetPatch } from "../hooks/use-undo-redo";
+type CitationProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeCitations: UseSpreadsheetProps<T, S>["onChangeCitations"];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+};
+/**
+ * Create a new citation and attach it to a cell
+ */
+export declare const createCitation: <T extends CellData, S extends Sheet>({ locale, onChangeSheetData, onChangeCitations, createHistory, }: CitationProps<T, S>) => (sheetId: number, rowIndex: number, columnIndex: number, citation: Citation) => void;
+/**
+ * Update an existing citation
+ */
+export declare const updateCitation: <T extends CellData, S extends Sheet>({ onChangeCitations, createHistory, }: Pick<CitationProps<T, S>, "onChangeCitations" | "createHistory">) => (citationId: string, updates: Partial<Omit<Citation, "id">>) => void;
+/**
+ * Remove a citation reference from a cell
+ */
+export declare const removeCitationFromCell: <T extends CellData, S extends Sheet>({ locale, onChangeSheetData, createHistory, }: Pick<CitationProps<T, S>, "locale" | "onChangeSheetData" | "createHistory">) => (sheetId: number, rowIndex: number, columnIndex: number) => void;
+/**
+ * Delete a citation completely (removes from citations array)
+ * Note: Cells with this citationId will still have the reference
+ */
+export declare const deleteCitation: <T extends CellData, S extends Sheet>({ onChangeCitations, createHistory, }: Pick<CitationProps<T, S>, "onChangeCitations" | "createHistory">) => (citationId: string) => void;
+/**
+ * Create multiple citations in a batch (adds to citations array only)
+ */
+export declare const createBatchCitations: <T extends CellData, S extends Sheet>({ onChangeCitations, createHistory, }: Pick<CitationProps<T, S>, "onChangeCitations" | "createHistory">) => (citations: Citation[]) => void;
+export {};
+//# sourceMappingURL=citations.d.ts.map

package/dist/esm/interface/citations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"citations.d.ts","sourceRoot":"","sources":["../../../interface/citations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,KAAK,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CAC1D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kEAKjE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,MAElB,SAAS,MAAM,EACf,UAAU,MAAM,EAChB,aAAa,MAAM,EACnB,UAAU,QAAQ,SA2CrB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,uCAGjE,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,mBAAmB,GAAG,eAAe,CAAC,MACzD,YAAY,MAAM,EAAE,SAAS,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,SAqBnE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAIzE,IAAI,CACL,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,QAAQ,GAAG,mBAAmB,GAAG,eAAe,CACjD,MACS,SAAS,MAAM,EAAE,UAAU,MAAM,EAAE,aAAa,MAAM,SAyB/D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,uCAGjE,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,mBAAmB,GAAG,eAAe,CAAC,MACzD,YAAY,MAAM,SAqB3B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,uCAGvE,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,mBAAmB,GAAG,eAAe,CAAC,MACzD,WAAW,QAAQ,EAAE,SAqB9B,CAAC"}

package/dist/esm/interface/citations.js

@@ -0,0 +1,123 @@
+import { produceWithPatches } from "immer";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+/**
+ * Create a new citation and attach it to a cell
+ */
+export const createCitation = ({ locale, onChangeSheetData, onChangeCitations, createHistory, }) => {
+    return (sheetId, rowIndex, columnIndex, citation) => {
+        const saveHistory = createHistory();
+        const sheetCell = new SheetCell();
+        // Add citation to citations array
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                draft.push(citation);
+            });
+            saveHistory?.({
+                citations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update cell to reference citation
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                    locale,
+                });
+                sheetCell.updateCitationId(citation.id);
+                currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            });
+            saveHistory?.({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+/**
+ * Update an existing citation
+ */
+export const updateCitation = ({ onChangeCitations, createHistory, }) => {
+    return (citationId, updates) => {
+        const saveHistory = createHistory();
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                const citation = draft.find((c) => c.id === citationId);
+                if (citation) {
+                    Object.assign(citation, updates);
+                }
+            });
+            saveHistory?.({
+                citations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+/**
+ * Remove a citation reference from a cell
+ */
+export const removeCitationFromCell = ({ locale, onChangeSheetData, createHistory, }) => {
+    return (sheetId, rowIndex, columnIndex) => {
+        const saveHistory = createHistory();
+        const sheetCell = new SheetCell();
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                    locale,
+                });
+                sheetCell.clearCitationId();
+                currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            });
+            saveHistory?.({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+/**
+ * Delete a citation completely (removes from citations array)
+ * Note: Cells with this citationId will still have the reference
+ */
+export const deleteCitation = ({ onChangeCitations, createHistory, }) => {
+    return (citationId) => {
+        const saveHistory = createHistory();
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                const index = draft.findIndex((c) => c.id === citationId);
+                if (index !== -1) {
+                    draft.splice(index, 1);
+                }
+            });
+            saveHistory?.({
+                citations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+/**
+ * Create multiple citations in a batch (adds to citations array only)
+ */
+export const createBatchCitations = ({ onChangeCitations, createHistory, }) => {
+    return (citations) => {
+        const saveHistory = createHistory();
+        // Add all citations to citations array
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                for (const citation of citations) {
+                    draft.push(citation);
+                }
+            });
+            saveHistory?.({
+                citations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/clear-formatting.d.ts

@@ -0,0 +1,5 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { UseOnClearFormattingProps } from "../hooks/use-on-clear-formatting";
+export declare const clearFormatting: <T extends CellData>({ locale, cellXfsRegistry, getDataValidationById, onChangeSheetData, createHistory, }: UseOnClearFormattingProps<T>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+//# sourceMappingURL=clear-formatting.d.ts.map

package/dist/esm/interface/clear-formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear-formatting.d.ts","sourceRoot":"","sources":["../../../interface/clear-formatting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAK/E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAGlF,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,QAAQ,EAAE,uFAMjD,yBAAyB,CAAC,CAAC,CAAC,MAE3B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAgEnD,CAAC"}

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

@@ -0,0 +1,48 @@
+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 const clearFormatting = ({ locale, cellXfsRegistry, getDataValidationById, onChangeSheetData, createHistory, }) => {
+    return (sheetId, activeCell, selections) => {
+        const finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        const saveHistory = createHistory();
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // Create a cell
+                const sheetCell = new SheetCell();
+                for (const sel of finalSelections) {
+                    for (const [rowIndex, columnIndex] of iterateCellsInRange(sel.range)) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        const cellData = currentSheet[rowIndex]?.values?.[columnIndex];
+                        // Create a cell
+                        sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, { locale, cellXfsRegistry, getDataValidationById });
+                        // Set user entered format
+                        sheetCell.clearUserEnteredFormat();
+                        // Set cell data
+                        currentSheet[rowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                        // Register cellXfs
+                        cellXfsRegistry?.unRegister(sheetCell);
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches,
+                    patches,
+                },
+                activeCell: { undo: activeCell, redo: activeCell },
+                selections: { undo: selections, redo: selections },
+                sheetId: { undo: sheetId, redo: undefined },
+            });
+            return nextState;
+        });
+        // Save cellXfs
+        cellXfsRegistry?.getPatches(saveHistory);
+    };
+};

package/dist/esm/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/esm/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/esm/interface/conditional-formatting-rules.js

@@ -0,0 +1,123 @@
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { isConditionalFormatFormulaRule } from "../api/conditional-format";
+import { dropXlsxSource } from "../api/xlsx-source";
+export const createConditionalFormattingRule = ({ enqueueCalculation, createHistory, onChangeConditionalFormats, }) => {
+    return (rule) => {
+        const saveHistory = createHistory();
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                draft.push(rule);
+                // Formula rule (include formula-backed rules too)
+                if (isConditionalFormatFormulaRule(rule)) {
+                    for (const range of rule.ranges) {
+                        for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                            enqueueCalculation({
+                                type: "add",
+                                position: {
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId: range.sheetId,
+                                    conditionalFormatId: rule.id,
+                                },
+                            });
+                        }
+                    }
+                }
+            });
+            saveHistory({
+                conditionalFormats: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const updateConditionalFormattingRule = ({ enqueueCalculation, createHistory, onChangeConditionalFormats, }) => {
+    return (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.
+        const sanitizedRule = dropXlsxSource(updatedRule);
+        const saveHistory = createHistory();
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const previousFormats = prevConditionalFormats.map((item) => {
+                if (item.id === sanitizedRule.id) {
+                    return previousRule;
+                }
+                return item;
+            });
+            const [nextState, patches, inversePatches] = produceWithPatches(previousFormats, (draft) => {
+                const idx = draft.findIndex((rule) => rule.id === sanitizedRule.id);
+                if (idx !== -1) {
+                    draft[idx] = sanitizedRule;
+                    for (const range of draft[idx].ranges) {
+                        for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                            enqueueCalculation({
+                                type: "add",
+                                position: {
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId: range.sheetId,
+                                    conditionalFormatId: sanitizedRule.id,
+                                },
+                            });
+                        }
+                    }
+                }
+            });
+            saveHistory({
+                conditionalFormats: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const deleteConditionalFormattingRule = ({ enqueueCalculation, createHistory, onChangeConditionalFormats, }) => {
+    return (rule) => {
+        const saveHistory = createHistory();
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                const idx = draft.findIndex((cur) => cur.id === rule.id);
+                if (idx !== -1) {
+                    // Formula rule
+                    if (isConditionalFormatFormulaRule(draft[idx])) {
+                        for (const range of draft[idx].ranges) {
+                            for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                                enqueueCalculation({
+                                    type: "remove",
+                                    position: {
+                                        rowIndex,
+                                        columnIndex,
+                                        sheetId: range.sheetId,
+                                        conditionalFormatId: draft[idx].id,
+                                    },
+                                });
+                            }
+                        }
+                    }
+                    draft.splice(idx, 1);
+                }
+            });
+            saveHistory({
+                conditionalFormats: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const previewConditionalFormattingRule = ({ onChangeConditionalFormats, }) => {
+    return (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.
+        const sanitizedRule = dropXlsxSource(rule);
+        // Prevent undo redo
+        onChangeConditionalFormats?.((prev) => {
+            return prev.map((cur) => {
+                if (cur.id === sanitizedRule.id) {
+                    return sanitizedRule;
+                }
+                return cur;
+            });
+        });
+    };
+};

package/dist/esm/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/esm/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/esm/interface/create-table.js

@@ -0,0 +1,105 @@
+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 const createTable = ({ locale, rowCount, columnCount, tables, basicFilter, theme: spreadsheetTheme, idCreationStrategy, enqueueCalculation, createHistory, onChangeSheets, onChangeTables, onChangeSheetData, getFormattedValue, getEffectiveValue, onRequestCalculate, getDependents, enqueueGraphOperation, getContentfulRangeAroundCell, generatedNames, }) => {
+    return (sheetId, activeCell, selections, tableSpec, theme, bandedRange) => {
+        // Validate
+        const lastSelection = selections?.[selections.length - 1];
+        const saveHistory = createHistory();
+        const range = tableSpec?.range
+            ? tableSpec.range
+            : lastSelection
+                ? lastSelection.range
+                : getContentfulRangeAroundCell?.(sheetId, activeCell) ??
+                    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, range }, tables)) {
+            return;
+        }
+        // Crate a table
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                const tableIndex = draft.findIndex((table) => (isCellWithinBounds(activeCell, table.range) ||
+                    areaIntersects(table.range, lastSelection?.range)) &&
+                    table.sheetId === sheetId);
+                if (tableIndex === -1) {
+                    const columns = [];
+                    for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                        const formattedValue = getFormattedValue(sheetId, range.startRowIndex, columnIndex);
+                        const columnName = getNextTableColumnName(columns, generatedNames);
+                        columns.push({
+                            name: formattedValue || columnName,
+                        });
+                    }
+                    draft.push({
+                        id: tableSpec?.id ?? idCreationStrategy?.("table") ?? uuid(),
+                        range,
+                        sheetId,
+                        title: tableSpec?.title ??
+                            getGeneratedTableName(draft.length + 1, generatedNames),
+                        columns,
+                        filterSpecs: [],
+                        headerRow: true,
+                        filterButton: true,
+                        sortSpecs: [],
+                        showRowStripes: true,
+                        bandedRange,
+                        theme: theme ?? "TableStyleLight1",
+                        ...tableSpec,
+                    });
+                }
+            });
+            // Mark table cells as dirty
+            // Skip marking table as empty
+            // const recalcCells = markTableAsDirty(
+            //   sheetId,
+            //   range,
+            //   getDependents,
+            //   enqueueCalculation
+            // );
+            saveHistory({
+                tables: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                addTableColumn({
+                    draft,
+                    getFormattedValue,
+                    sheetId,
+                    range,
+                    locale,
+                    generatedNames,
+                });
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Check if user is creating a table in basicFilter
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet && isAreasEqual(sheet.basicFilter?.range, range)) {
+                    sheet.basicFilter = undefined;
+                }
+            });
+            if (patches.length) {
+                saveHistory({
+                    sheets: {
+                        patches,
+                        inversePatches,
+                    },
+                });
+            }
+            return nextState;
+        });
+    };
+};

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