@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/change-table-column.js

@@ -0,0 +1,267 @@
+import { __assign, __read, __values } from "tslib";
+import { isStaticNode } from "@rowsncolumns/dag";
+import { getCellXfsKey, isNil, iterateCellsInRange, } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { removeTableName } from "../api/table";
+import { getNextTableColumnName } from "../helpers";
+import { SheetCell } from "../sheet-cell";
+export var changeTableColumn = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, onChangeSheetData = _a.onChangeSheetData, onChangeTables = _a.onChangeTables, getDependents = _a.getDependents, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, createHistory = _a.createHistory, tokenizer = _a.tokenizer, generatedNames = _a.generatedNames;
+    return function (sheetId, coords, value, currentTable, isRowExpansion, isColumnExpansion, range) {
+        var _a, _b;
+        if (isNil(currentTable)) {
+            return;
+        }
+        var recalcCells = new Map();
+        var newColumnName = isColumnExpansion
+            ? currentTable.range.startRowIndex === coords.rowIndex
+                ? value
+                    ? String(value)
+                    : getNextTableColumnName((_a = currentTable.columns) !== null && _a !== void 0 ? _a : undefined, generatedNames)
+                : getNextTableColumnName((_b = currentTable.columns) !== null && _b !== void 0 ? _b : undefined, generatedNames)
+            : undefined;
+        var isEnteringNewColumnName = currentTable.range.startRowIndex === coords.rowIndex;
+        var saveHistory = createHistory();
+        var isAdjacentColumn = coords.columnIndex === currentTable.range.endColumnIndex + 1;
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a;
+                if (isAdjacentColumn && !isNil(value) && typeof value !== "boolean") {
+                    var currentSheet = createSheetDraft(draft, sheetId, coords.rowIndex);
+                    var sheetCell = new SheetCell(sheetId, coords, (_a = currentSheet === null || currentSheet === void 0 ? void 0 : currentSheet[coords.rowIndex].values) === null || _a === void 0 ? void 0 : _a[coords.columnIndex], { locale: locale, cellXfsRegistry: cellXfsRegistry, sharedStringRegistry: sharedStringRegistry });
+                    var finalValue = sheetCell.formula && tokenizer
+                        ? removeTableName(tokenizer(value), currentTable.title)
+                        : value;
+                    sheetCell.setUserEnteredValue(finalValue);
+                    currentSheet[coords.rowIndex].values[coords.columnIndex] =
+                        sheetCell.getCellData();
+                    recalcCells.set(createSheetCellIdentifier(sheetId, coords.rowIndex, coords.columnIndex), __assign(__assign({}, coords), { sheetId: sheetId }));
+                }
+                if (isColumnExpansion && !isEnteringNewColumnName) {
+                    var columnCell = {
+                        rowIndex: currentTable.range.startRowIndex,
+                        columnIndex: currentTable.range.endColumnIndex + 1,
+                    };
+                    var currentSheet = createSheetDraft(draft, sheetId, columnCell.rowIndex);
+                    var sheetCell = new SheetCell(sheetId, columnCell, undefined, {
+                        locale: locale,
+                    });
+                    sheetCell.setUserEnteredValue(newColumnName);
+                    currentSheet[columnCell.rowIndex].values[columnCell.columnIndex] =
+                        sheetCell.getCellData();
+                    enqueueGraphOperation({
+                        position: __assign(__assign({}, columnCell), { sheetId: sheetId }),
+                        type: "add",
+                    });
+                    recalcCells.set(createSheetCellIdentifier(sheetId, columnCell.rowIndex, columnCell.columnIndex), __assign(__assign({}, columnCell), { sheetId: sheetId }));
+                }
+                if (isRowExpansion) {
+                    recalcCells.set(createSheetCellIdentifier(sheetId, coords.rowIndex, coords.columnIndex), __assign(__assign({}, coords), { sheetId: sheetId }));
+                    addCalculatedColumnsForRowExpansion({
+                        sheetId: sheetId,
+                        locale: locale,
+                        currentTable: currentTable,
+                        draft: draft,
+                        enqueueCalculation: enqueueCalculation,
+                        recalcCells: recalcCells,
+                        range: __assign(__assign({}, currentTable.range), { startRowIndex: range.startRowIndex, endRowIndex: range.endRowIndex }),
+                        getDependents: getDependents,
+                    });
+                    propagateColumnFormatsForRowExpansion({
+                        sheetId: sheetId,
+                        locale: locale,
+                        currentTable: currentTable,
+                        draft: draft,
+                        cellXfsRegistry: cellXfsRegistry,
+                        newRowStart: coords.rowIndex,
+                        newRowEnd: coords.rowIndex + (range.endRowIndex - range.startRowIndex),
+                    });
+                }
+                if (isRowExpansion || isColumnExpansion) {
+                    processTableDependentCells(currentTable, getDependents, recalcCells, enqueueCalculation);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory(__assign({ sheetData: { patches: patches, inversePatches: inversePatches }, recalcCells: { undo: recalcCells, redo: recalcCells } }, (isAdjacentColumn
+                ? { activeCell: { undo: coords, redo: coords } }
+                : {})));
+            return nextState;
+        });
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTableData) {
+            var _a = __read(produceWithPatches(prevTableData, function (draft) {
+                var _a;
+                var table = draft.find(function (table) { return table.id === currentTable.id && table.sheetId === sheetId; });
+                if (table) {
+                    if (isRowExpansion) {
+                        table.range.endRowIndex = Math.max(table.range.endRowIndex, coords.rowIndex + (range.endRowIndex - range.startRowIndex));
+                    }
+                    if (isColumnExpansion && newColumnName) {
+                        table.range.endColumnIndex += 1;
+                        (_a = table.columns) === null || _a === void 0 ? void 0 : _a.push({
+                            name: newColumnName,
+                            filterButton: true,
+                        });
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var addCalculatedColumnsForRowExpansion = function (_a) {
+    var _b, _c, _d, _e, _f;
+    var sheetId = _a.sheetId, locale = _a.locale, currentTable = _a.currentTable, draft = _a.draft, recalcCells = _a.recalcCells, range = _a.range, enqueueCalculation = _a.enqueueCalculation, getDependents = _a.getDependents;
+    var sheetCell = new SheetCell();
+    for (var i = 0; i < ((_c = (_b = currentTable.columns) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0); i++) {
+        var column = (_d = currentTable.columns) === null || _d === void 0 ? void 0 : _d[i];
+        if (column && column.formula) {
+            var newRange = __assign(__assign({}, range), { startRowIndex: currentTable.range.startRowIndex +
+                    (((_e = currentTable.headerRow) !== null && _e !== void 0 ? _e : true) ? 1 : 0), startColumnIndex: currentTable.range.startColumnIndex + i, endColumnIndex: currentTable.range.startColumnIndex + i });
+            for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                for (var columnIndex = newRange.startColumnIndex; columnIndex <= newRange.endColumnIndex; columnIndex++) {
+                    if (!getDependents({ sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex }).length) {
+                        continue;
+                    }
+                    var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    var cellData = (_f = currentSheet[rowIndex].values) === null || _f === void 0 ? void 0 : _f[columnIndex];
+                    sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                        locale: locale,
+                    });
+                    sheetCell.setUserEnteredValue(column.formula);
+                    currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+                    enqueueCalculation({
+                        type: "add",
+                        position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                    });
+                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                        rowIndex: rowIndex,
+                        columnIndex: columnIndex,
+                        sheetId: sheetId,
+                    });
+                }
+            }
+        }
+    }
+};
+/**
+ * When a table auto-expands downward, Excel applies the column's
+ * existing formatting to the new row's cells -- but only when every
+ * body cell in that column shares the same `userEnteredFormat`. If a
+ * column is inconsistent (user painted A2 red, A3 black, A4 blue),
+ * Excel applies nothing there. The whole row is styled at the moment
+ * of expansion so the band doesn't appear column-by-column as the
+ * user types into siblings. This implements that pass.
+ *
+ * Banded fills themselves come from the table style at render time
+ * (see `apps/spreadsheet/components/canvas-grid` -- `getBandedCells`
+ * / `getBandedCellFormat`), so this only handles user-applied
+ * formats: number format, borders, fill, font, data-validation-driven
+ * styling, etc.
+ */
+export var propagateColumnFormatsForRowExpansion = function (_a) {
+    var _b, _c, _d, _e, _f;
+    var sheetId = _a.sheetId, locale = _a.locale, currentTable = _a.currentTable, draft = _a.draft, cellXfsRegistry = _a.cellXfsRegistry, newRowStart = _a.newRowStart, newRowEnd = _a.newRowEnd;
+    var _g = currentTable.range, startColumnIndex = _g.startColumnIndex, endColumnIndex = _g.endColumnIndex, startRowIndex = _g.startRowIndex, endRowIndex = _g.endRowIndex;
+    var bodyStart = startRowIndex + (((_b = currentTable.headerRow) !== null && _b !== void 0 ? _b : true) ? 1 : 0);
+    var bodyEnd = endRowIndex;
+    if (bodyEnd < bodyStart)
+        return;
+    // No-op: nothing to do when the "new" rows are inside the existing
+    // body range (re-entering an existing row, not expanding).
+    if (newRowStart <= bodyEnd)
+        return;
+    var probe = new SheetCell();
+    var target = new SheetCell();
+    for (var columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+        var sharedKey = void 0;
+        var sharedFormat = void 0;
+        var consistent = true;
+        for (var r = bodyStart; r <= bodyEnd; r++) {
+            var cellData = (_e = (_d = (_c = draft[sheetId]) === null || _c === void 0 ? void 0 : _c[r]) === null || _d === void 0 ? void 0 : _d.values) === null || _e === void 0 ? void 0 : _e[columnIndex];
+            probe.assign(sheetId, { rowIndex: r, columnIndex: columnIndex }, cellData, { locale: locale, cellXfsRegistry: cellXfsRegistry });
+            var resolved = probe.getUserEnteredFormat();
+            if (!resolved) {
+                consistent = false;
+                break;
+            }
+            var key = getCellXfsKey(resolved);
+            if (sharedKey === undefined) {
+                sharedKey = key;
+                sharedFormat = resolved;
+            }
+            else if (key !== sharedKey) {
+                consistent = false;
+                break;
+            }
+        }
+        if (!consistent || !sharedFormat)
+            continue;
+        for (var r = newRowStart; r <= newRowEnd; r++) {
+            var currentSheet = createSheetDraft(draft, sheetId, r);
+            var existingCell = (_f = currentSheet[r].values) === null || _f === void 0 ? void 0 : _f[columnIndex];
+            target.assign(sheetId, { rowIndex: r, columnIndex: columnIndex }, existingCell, { locale: locale, cellXfsRegistry: cellXfsRegistry });
+            if (target.getUserEnteredFormat())
+                continue;
+            target.inheritFormat(sharedFormat);
+            currentSheet[r].values[columnIndex] = target.getCellData();
+        }
+    }
+};
+export var processTableDependentCells = function (table, getDependents, recalcCells, enqueueCalculation) {
+    var e_1, _a, e_2, _b, e_3, _c;
+    var deps = new Set();
+    try {
+        for (var _d = __values(iterateCellsInRange(table.range)), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var _f = __read(_e.value, 2), rowIndex = _f[0], columnIndex = _f[1];
+            var dependents = getDependents({
+                rowIndex: rowIndex,
+                columnIndex: columnIndex,
+                sheetId: table.sheetId,
+            });
+            try {
+                for (var dependents_1 = (e_2 = void 0, __values(dependents)), dependents_1_1 = dependents_1.next(); !dependents_1_1.done; dependents_1_1 = dependents_1.next()) {
+                    var dependent = dependents_1_1.value;
+                    if (isStaticNode(dependent)) {
+                        continue;
+                    }
+                    deps.add(dependent);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (dependents_1_1 && !dependents_1_1.done && (_b = dependents_1.return)) _b.call(dependents_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var deps_1 = __values(deps), deps_1_1 = deps_1.next(); !deps_1_1.done; deps_1_1 = deps_1.next()) {
+            var position = deps_1_1.value.position;
+            enqueueCalculation({
+                type: "add",
+                position: position,
+            });
+            recalcCells.set(createSheetCellIdentifier(table.sheetId, position.rowIndex, position.columnIndex), position);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (deps_1_1 && !deps_1_1.done && (_c = deps_1.return)) _c.call(deps_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+};

package/dist/cjs/interface/change-theme.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, SpreadsheetTheme } from "@rowsncolumns/spreadsheet";
+import type { UseOnChangeThemeProps } from "../hooks/use-on-change-theme";
+export declare const changeTheme: <T extends CellData>({ createHistory, onChangeTheme, }: UseOnChangeThemeProps<T>) => (theme: SpreadsheetTheme) => void;
+//# sourceMappingURL=change-theme.d.ts.map

package/dist/cjs/interface/change-theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-theme.d.ts","sourceRoot":"","sources":["../../../interface/change-theme.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAG5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAE1E,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,mCAG7C,qBAAqB,CAAC,CAAC,CAAC,MACjB,OAAO,gBAAgB,SAyBhC,CAAC"}

package/dist/cjs/interface/change-theme.js

@@ -0,0 +1,23 @@
+import { __read } from "tslib";
+import { produceWithPatches } from "immer";
+export var changeTheme = function (_a) {
+    var createHistory = _a.createHistory, onChangeTheme = _a.onChangeTheme;
+    return function (theme) {
+        var saveHistory = createHistory();
+        // if (theme.primaryFontFamily !== "Arial") {
+        // await loadWebFont([
+        //   theme.primaryFontFamily,
+        //   `${theme.primaryFontFamily}:bold`,
+        // ]).catch(() => {
+        //   console.log("Error loading font", theme);
+        // });
+        // }
+        onChangeTheme === null || onChangeTheme === void 0 ? void 0 : onChangeTheme(function (prevTheme) {
+            var _a = __read(produceWithPatches(prevTheme, function () { return theme; }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                theme: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/interface/chart-extensions.d.ts

@@ -0,0 +1,32 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, EmbeddedChart, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+type CreateChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    getFormattedValue: any;
+    getEffectiveValue: any;
+    createHistory: any;
+}) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], chartSpec?: EmbeddedChart) => void;
+type DeleteChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    createHistory: any;
+}) => (chartId: string | number) => void;
+type MoveChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    createHistory: any;
+}) => (chartId: string | number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number) => void;
+type ResizeChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    createHistory: any;
+}) => (chartId: string | number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number, width: number, height: number) => void;
+type UpdateChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    createHistory: any;
+}) => (chart: EmbeddedChart) => void;
+export declare const isChartsAvailable: () => boolean;
+export declare const safeCreateChart: CreateChartFunction;
+export declare const safeDeleteChart: DeleteChartFunction;
+export declare const safeMoveChart: MoveChartFunction;
+export declare const safeResizeChart: ResizeChartFunction;
+export declare const safeUpdateChart: UpdateChartFunction;
+export {};
+//# sourceMappingURL=chart-extensions.d.ts.map

package/dist/cjs/interface/chart-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-extensions.d.ts","sourceRoot":"","sources":["../../../interface/chart-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,mBAAmB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACrD,cAAc,EAAE,GAAG,CAAC;IACpB,iBAAiB,EAAE,GAAG,CAAC;IACvB,iBAAiB,EAAE,GAAG,CAAC;IACvB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CACJ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,aAAa,EACzB,UAAU,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,SAAS,CAAC,EAAE,aAAa,KACtB,IAAI,CAAC;AAEV,KAAK,mBAAmB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACrD,cAAc,EAAE,GAAG,CAAC;IACpB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;AAEzC,KAAK,iBAAiB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACnD,cAAc,EAAE,GAAG,CAAC;IACpB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CACJ,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,UAAU,EAAE,aAAa,EACzB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,KAClB,IAAI,CAAC;AAEV,KAAK,mBAAmB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACrD,cAAc,EAAE,GAAG,CAAC;IACpB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CACJ,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,UAAU,EAAE,aAAa,EACzB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,IAAI,CAAC;AAEV,KAAK,mBAAmB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACrD,cAAc,EAAE,GAAG,CAAC;IACpB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AA8BrC,eAAO,MAAM,iBAAiB,QAAO,OAQpC,CAAC;AAUF,eAAO,MAAM,eAAe,EAAE,mBAK7B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,mBAK7B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,iBAK3B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,mBAK7B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,mBAK7B,CAAC"}

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

@@ -0,0 +1,71 @@
+import { enablePatches } from "immer";
+enablePatches();
+// Chart function imports with fallbacks
+var createChart = null;
+var deleteChart = null;
+var moveChart = null;
+var resizeChart = null;
+var 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 (_a) {
+    // Charts package not available - functions will remain null
+}
+// Helper function to check if charts are available
+export var isChartsAvailable = function () {
+    return (createChart !== null &&
+        deleteChart !== null &&
+        moveChart !== null &&
+        resizeChart !== null &&
+        updateChart !== null);
+};
+// Helper function to throw error when charts are not available
+var throwChartsNotAvailable = function (operation) {
+    throw new Error("Chart ".concat(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 var safeCreateChart = function (props) {
+    if (!createChart) {
+        throwChartsNotAvailable("create");
+    }
+    return createChart(props);
+};
+export var safeDeleteChart = function (props) {
+    if (!deleteChart) {
+        throwChartsNotAvailable("delete");
+    }
+    return deleteChart(props);
+};
+export var safeMoveChart = function (props) {
+    if (!moveChart) {
+        throwChartsNotAvailable("move");
+    }
+    return moveChart(props);
+};
+export var safeResizeChart = function (props) {
+    if (!resizeChart) {
+        throwChartsNotAvailable("resize");
+    }
+    return resizeChart(props);
+};
+export var safeUpdateChart = function (props) {
+    if (!updateChart) {
+        throwChartsNotAvailable("update");
+    }
+    return updateChart(props);
+};

package/dist/cjs/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/cjs/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/cjs/interface/citations.js

@@ -0,0 +1,142 @@
+import { __read, __values } from "tslib";
+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 var createCitation = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, onChangeCitations = _a.onChangeCitations, createHistory = _a.createHistory;
+    return function (sheetId, rowIndex, columnIndex, citation) {
+        var saveHistory = createHistory();
+        var sheetCell = new SheetCell();
+        // Add citation to citations array
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                draft.push(citation);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory === null || saveHistory === void 0 ? void 0 : saveHistory({
+                citations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update cell to reference citation
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                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,
+                });
+                sheetCell.updateCitationId(citation.id);
+                currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory === null || saveHistory === void 0 ? void 0 : saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+/**
+ * Update an existing citation
+ */
+export var updateCitation = function (_a) {
+    var onChangeCitations = _a.onChangeCitations, createHistory = _a.createHistory;
+    return function (citationId, updates) {
+        var saveHistory = createHistory();
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                var citation = draft.find(function (c) { return c.id === citationId; });
+                if (citation) {
+                    Object.assign(citation, updates);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory === null || saveHistory === void 0 ? void 0 : saveHistory({
+                citations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+/**
+ * Remove a citation reference from a cell
+ */
+export var removeCitationFromCell = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory;
+    return function (sheetId, rowIndex, columnIndex) {
+        var saveHistory = createHistory();
+        var sheetCell = new SheetCell();
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                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,
+                });
+                sheetCell.clearCitationId();
+                currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory === null || saveHistory === void 0 ? void 0 : saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+/**
+ * Delete a citation completely (removes from citations array)
+ * Note: Cells with this citationId will still have the reference
+ */
+export var deleteCitation = function (_a) {
+    var onChangeCitations = _a.onChangeCitations, createHistory = _a.createHistory;
+    return function (citationId) {
+        var saveHistory = createHistory();
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                var index = draft.findIndex(function (c) { return c.id === citationId; });
+                if (index !== -1) {
+                    draft.splice(index, 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory === null || saveHistory === void 0 ? void 0 : saveHistory({
+                citations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+/**
+ * Create multiple citations in a batch (adds to citations array only)
+ */
+export var createBatchCitations = function (_a) {
+    var onChangeCitations = _a.onChangeCitations, createHistory = _a.createHistory;
+    return function (citations) {
+        var saveHistory = createHistory();
+        // Add all citations to citations array
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                var e_1, _a;
+                try {
+                    for (var citations_1 = __values(citations), citations_1_1 = citations_1.next(); !citations_1_1.done; citations_1_1 = citations_1.next()) {
+                        var citation = citations_1_1.value;
+                        draft.push(citation);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (citations_1_1 && !citations_1_1.done && (_a = citations_1.return)) _a.call(citations_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory === null || saveHistory === void 0 ? void 0 : saveHistory({
+                citations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

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