@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/interface-cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env bun
+import { __awaiter, __extends, __generator } from "tslib";
+import { Spreadsheet } from "./spreadsheet-interface";
+import { attachCalculationWorker, } from "@rowsncolumns/calculation-worker";
+var InlineWorkerScope = /** @class */ (function (_super) {
+    __extends(InlineWorkerScope, _super);
+    function InlineWorkerScope(notifyParent) {
+        var _this = _super.call(this) || this;
+        _this.notifyParent = notifyParent;
+        return _this;
+    }
+    InlineWorkerScope.prototype.postMessage = function (data) {
+        this.notifyParent(data);
+    };
+    return InlineWorkerScope;
+}(EventTarget));
+var InlineWorker = /** @class */ (function (_super) {
+    __extends(InlineWorker, _super);
+    function InlineWorker(options) {
+        var _this = _super.call(this) || this;
+        _this.scope = new InlineWorkerScope(function (message) {
+            queueMicrotask(function () {
+                _this.dispatchEvent(new MessageEvent("message", { data: message }));
+            });
+        });
+        _this.disposeRuntime = attachCalculationWorker(_this.scope, options);
+        return _this;
+    }
+    InlineWorker.prototype.postMessage = function (message) {
+        var _this = this;
+        queueMicrotask(function () {
+            _this.scope.dispatchEvent(new MessageEvent("message", { data: message }));
+        });
+    };
+    InlineWorker.prototype.terminate = function () {
+        this.disposeRuntime.dispose();
+    };
+    return InlineWorker;
+}(EventTarget));
+var main = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var spreadsheet, results;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                spreadsheet = new Spreadsheet({
+                    createCalculationWorker: function () { return new InlineWorker(); },
+                });
+                spreadsheet.sheets = [
+                    { sheetId: 1, rowCount: 10, columnCount: 10, title: "Sheet1" },
+                ];
+                spreadsheet.sheetData = { 1: [] };
+                spreadsheet.changeBatch(1, {
+                    startRowIndex: 1,
+                    endRowIndex: 1,
+                    startColumnIndex: 1,
+                    endColumnIndex: 1,
+                }, [[3]]);
+                spreadsheet.changeBatch(1, {
+                    startRowIndex: 1,
+                    endRowIndex: 1,
+                    startColumnIndex: 2,
+                    endColumnIndex: 2,
+                }, [["=A1*4"]]);
+                spreadsheet.enqueueCalculation({
+                    type: "add",
+                    position: { sheetId: 1, rowIndex: 1, columnIndex: 2 },
+                });
+                return [4 /*yield*/, spreadsheet.calculatePending()];
+            case 1:
+                results = _a.sent();
+                console.log("calculation results", results);
+                return [2 /*return*/];
+        }
+    });
+}); };
+void main();

package/dist/cjs/interface/named-range-operations.d.ts

@@ -0,0 +1,19 @@
+import type { CellData, NamedRange } from "@rowsncolumns/spreadsheet";
+import type { useCalculation } from "../hooks/use-calculation";
+import type { UseSpreadsheetProps } from "../hooks/use-spreadsheet-state";
+import type { SpreadsheetPatch } from "../hooks/use-undo-redo";
+type UseOnCreateNamedRangeProps<T extends CellData> = {
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    onChangeNamedRanges: UseSpreadsheetProps<T>["onChangeNamedRanges"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+};
+type UseOnDeleteNamedRangeProps<T extends CellData> = {
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    onChangeNamedRanges: UseSpreadsheetProps<T>["onChangeNamedRanges"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+};
+export declare const createNamedRange: <T extends CellData>({ enqueueCalculation, createHistory, onChangeNamedRanges, }: UseOnCreateNamedRangeProps<T>) => (sheetId: number, namedRange: NamedRange) => void;
+export declare const deleteNamedRange: <T extends CellData>({ getDependents, enqueueCalculation, createHistory, onChangeNamedRanges, }: UseOnDeleteNamedRangeProps<T>) => (id: NamedRange["namedRangeId"]) => void;
+export {};
+//# sourceMappingURL=named-range-operations.d.ts.map

package/dist/cjs/interface/named-range-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"named-range-operations.d.ts","sourceRoot":"","sources":["../../../interface/named-range-operations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAKtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACnE,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACtD,CAAC;AAEF,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACnE,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACtD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,6DAIlD,0BAA0B,CAAC,CAAC,CAAC,MACtB,SAAS,MAAM,EAAE,YAAY,UAAU,SAsChD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,4EAKlD,0BAA0B,CAAC,CAAC,CAAC,MACtB,IAAI,UAAU,CAAC,cAAc,CAAC,SAiDvC,CAAC"}

package/dist/cjs/interface/named-range-operations.js

@@ -0,0 +1,96 @@
+import { __read, __values } from "tslib";
+import { isStaticNode } from "@rowsncolumns/dag";
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+export var createNamedRange = function (_a) {
+    var enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onChangeNamedRanges = _a.onChangeNamedRanges;
+    return function (sheetId, namedRange) {
+        var saveHistory = createHistory();
+        onChangeNamedRanges === null || onChangeNamedRanges === void 0 ? void 0 : onChangeNamedRanges(function (prevNamedRanges) {
+            var _a = __read(produceWithPatches(prevNamedRanges, function (draft) {
+                var e_1, _a;
+                // Check if there is a named range with the same name
+                var exists = draft.find(function (n) { return n.name === namedRange.name; });
+                if (!exists) {
+                    draft.push(namedRange);
+                    // Make cells dirty
+                    if (namedRange.range) {
+                        try {
+                            for (var _b = __values(iterateCellsInRange(namedRange.range)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                                enqueueCalculation({
+                                    position: {
+                                        rowIndex: rowIndex,
+                                        columnIndex: columnIndex,
+                                        sheetId: sheetId,
+                                    },
+                                    type: "add",
+                                });
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                namedRanges: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var deleteNamedRange = function (_a) {
+    var getDependents = _a.getDependents, enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onChangeNamedRanges = _a.onChangeNamedRanges;
+    return function (id) {
+        var saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        onChangeNamedRanges === null || onChangeNamedRanges === void 0 ? void 0 : onChangeNamedRanges(function (prevNamedRanges) {
+            var _a = __read(produceWithPatches(prevNamedRanges, function (draft) {
+                var e_2, _a;
+                // Check if there is a named range with the same name
+                var index = draft.findIndex(function (n) { return n.namedRangeId === id; });
+                if (index !== -1) {
+                    var range = draft[index].range;
+                    // Make dependent dirty
+                    if (range) {
+                        try {
+                            for (var _b = __values(getDependents(range)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                var dependency = _c.value;
+                                if (isStaticNode(dependency)) {
+                                    continue;
+                                }
+                                var position = dependency.position;
+                                enqueueCalculation({
+                                    position: position,
+                                    type: "dirty",
+                                });
+                                recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                    draft.splice(index, 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                namedRanges: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/interface/new-sheet.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnCreateSheetProps } from "../hooks/use-on-create-sheet";
+export declare const createNewSheet: <T extends CellData, S extends Sheet>({ sheetId, maxSheetCount, sheets, maxRowCount, maxColumnCount, idCreationStrategy, onChangeSheets, onChangeActiveSheet, createHistory, generatedNames, }: UseOnCreateSheetProps<T, S>) => (sheetSpec?: Partial<Sheet>) => S;
+//# sourceMappingURL=new-sheet.d.ts.map

package/dist/cjs/interface/new-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new-sheet.d.ts","sourceRoot":"","sources":["../../../interface/new-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAUjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAmB1E,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,0JAWjE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MACpB,YAAY,OAAO,CAAC,KAAK,CAAC,KA6HT,CAE1B,CAAC"}

package/dist/cjs/interface/new-sheet.js

@@ -0,0 +1,109 @@
+import { __assign, __read, __spreadArray } from "tslib";
+import { uuid } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { getGeneratedSheetName } from "../generated-names";
+import { MAX_SHEET_TITLE_LENGTH, truncateSheetTitle, } from "../helpers/sheet-title";
+var createNewSheetHelper = function (sheetId, title, rowCount, columnCount, hidden) {
+    if (rowCount === void 0) { rowCount = 1000; }
+    if (columnCount === void 0) { columnCount = 100; }
+    if (hidden === void 0) { hidden = false; }
+    return ({
+        title: title,
+        sheetId: sheetId,
+        rowCount: rowCount,
+        columnCount: columnCount,
+        hidden: hidden,
+        merges: [],
+        columnMetadata: [],
+        rowMetadata: [],
+    });
+};
+export var createNewSheet = function (_a) {
+    var sheetId = _a.sheetId, maxSheetCount = _a.maxSheetCount, sheets = _a.sheets, maxRowCount = _a.maxRowCount, maxColumnCount = _a.maxColumnCount, idCreationStrategy = _a.idCreationStrategy, onChangeSheets = _a.onChangeSheets, onChangeActiveSheet = _a.onChangeActiveSheet, createHistory = _a.createHistory, generatedNames = _a.generatedNames;
+    return function (sheetSpec) {
+        var saveHistory = createHistory();
+        var createdSheet;
+        // Move ALL uniqueness logic inside produceWithPatches to use the latest draft state
+        // This ensures concurrent calls see each other's changes
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a, _b, _c, _d, _e, _f, _g;
+                // Generate unique sheetId using the CURRENT draft state
+                var newSheetId = (_b = (_a = sheetSpec === null || sheetSpec === void 0 ? void 0 : sheetSpec.sheetId) !== null && _a !== void 0 ? _a : idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("sheet")) !== null && _b !== void 0 ? _b : uuid();
+                var existingIds = new Set(draft.map(function (s) { return s.sheetId; }));
+                // If ID already exists, generate a new one
+                while (existingIds.has(newSheetId)) {
+                    newSheetId = (_c = idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("sheet")) !== null && _c !== void 0 ? _c : uuid();
+                }
+                // Check if this exact sheet already exists (by ID)
+                if ((sheetSpec === null || sheetSpec === void 0 ? void 0 : sheetSpec.sheetId) && existingIds.has(sheetSpec.sheetId)) {
+                    createdSheet = draft.find(function (s) { return s.sheetId === sheetSpec.sheetId; });
+                    return; // Don't add duplicate
+                }
+                // Generate unique title using the CURRENT draft state
+                var baseTitle = truncateSheetTitle((sheetSpec === null || sheetSpec === void 0 ? void 0 : sheetSpec.title) ||
+                    getGeneratedSheetName(draft.length + 1, generatedNames));
+                var finalTitle = baseTitle;
+                var counter = 1;
+                var existingTitles = new Set(draft.map(function (s) { return s.title; }));
+                while (existingTitles.has(finalTitle)) {
+                    var suffix = "".concat(counter);
+                    var titlePrefix = baseTitle.slice(0, Math.max(0, MAX_SHEET_TITLE_LENGTH - suffix.length));
+                    finalTitle = "".concat(titlePrefix).concat(suffix);
+                    counter++;
+                }
+                // Create the new sheet
+                var newSheet = createNewSheetHelper(newSheetId, finalTitle, (_d = sheetSpec === null || sheetSpec === void 0 ? void 0 : sheetSpec.rowCount) !== null && _d !== void 0 ? _d : maxRowCount, (_e = sheetSpec === null || sheetSpec === void 0 ? void 0 : sheetSpec.columnCount) !== null && _e !== void 0 ? _e : maxColumnCount, (_f = sheetSpec === null || sheetSpec === void 0 ? void 0 : sheetSpec.hidden) !== null && _f !== void 0 ? _f : false);
+                // Determine visual insertion index (after current active sheet) without
+                // mutating existing array positions. This keeps ShareDB patches append-only.
+                var orderedSheets = draft
+                    .map(function (s, arrayIndex) {
+                    var _a;
+                    return ({
+                        sheet: s,
+                        effectiveIndex: (_a = s.index) !== null && _a !== void 0 ? _a : arrayIndex,
+                        arrayIndex: arrayIndex,
+                    });
+                })
+                    .sort(function (a, b) {
+                    return a.effectiveIndex - b.effectiveIndex ||
+                        a.arrayIndex - b.arrayIndex;
+                });
+                var activeOrderedIndex = orderedSheets.findIndex(function (entry) { return entry.sheet.sheetId === sheetId; });
+                var fallbackMaxIndex = orderedSheets.length > 0
+                    ? Math.max.apply(Math, __spreadArray([], __read(orderedSheets.map(function (entry) { return entry.effectiveIndex; })), false)) : -1;
+                var computedIndex = activeOrderedIndex === -1
+                    ? fallbackMaxIndex + 1
+                    : (function () {
+                        var _a, _b, _c;
+                        var currentIndex = (_b = (_a = orderedSheets[activeOrderedIndex]) === null || _a === void 0 ? void 0 : _a.effectiveIndex) !== null && _b !== void 0 ? _b : fallbackMaxIndex;
+                        var nextIndex = (_c = orderedSheets[activeOrderedIndex + 1]) === null || _c === void 0 ? void 0 : _c.effectiveIndex;
+                        return nextIndex === undefined
+                            ? currentIndex + 1
+                            : currentIndex + (nextIndex - currentIndex) / 2;
+                    })();
+                // Merge any additional spec properties
+                var sheet = __assign(__assign(__assign({}, newSheet), sheetSpec), { 
+                    // Ensure computed values override spec
+                    sheetId: newSheetId, title: finalTitle, index: (_g = sheetSpec === null || sheetSpec === void 0 ? void 0 : sheetSpec.index) !== null && _g !== void 0 ? _g : computedIndex });
+                // Always append physically to keep patches as add-only.
+                draft.push(sheet);
+                createdSheet = sheet;
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save to history only if a sheet was created
+            if (createdSheet) {
+                saveHistory({
+                    sheets: { patches: patches, inversePatches: inversePatches },
+                    sheetId: { undo: sheetId, redo: createdSheet.sheetId },
+                });
+            }
+            return nextState;
+        });
+        // Update active sheet id
+        if (createdSheet) {
+            onChangeActiveSheet(createdSheet.sheetId);
+        }
+        // Return the created/existing sheet
+        return createdSheet;
+    };
+};

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

@@ -0,0 +1,27 @@
+import type { PivotTable } from "@rowsncolumns/common-types";
+type CreatePivotTableFunction = (props: any) => (pivotTable: PivotTable, shouldCreateNewChart?: boolean, database?: any) => void;
+type DeletePivotTableFunction = (props: any) => (pivotId: PivotTable["pivotId"], database?: any) => void;
+export type PivotModule = {
+    createPivotTable?: CreatePivotTableFunction;
+    deletePivotTable?: DeletePivotTableFunction;
+};
+/**
+ * Register the pivot module explicitly. Required in environments where the
+ * fallback dynamic `require("@rowsncolumns/pivot/server")` cannot resolve at
+ * runtime: bun --compile single-file binaries, pure Node ESM, edge runtimes.
+ *
+ * Call once at startup, before invoking pivot operations:
+ *
+ * ```ts
+ * import * as pivotServer from "@rowsncolumns/pivot/server";
+ * import { registerPivotModule } from "@rowsncolumns/spreadsheet-state/server";
+ *
+ * registerPivotModule(pivotServer);
+ * ```
+ */
+export declare const registerPivotModule: (module: PivotModule) => void;
+export declare const isPivotAvailable: () => boolean;
+export declare const safeCreatePivotTable: CreatePivotTableFunction;
+export declare const safeDeletePivotTable: DeletePivotTableFunction;
+export {};
+//# sourceMappingURL=pivot-extensions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pivot-extensions.d.ts","sourceRoot":"","sources":["../../../interface/pivot-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,KAAK,wBAAwB,GAAG,CAC9B,KAAK,EAAE,GAAG,KACP,CACH,UAAU,EAAE,UAAU,EACtB,oBAAoB,CAAC,EAAE,OAAO,EAC9B,QAAQ,CAAC,EAAE,GAAG,KACX,IAAI,CAAC;AACV,KAAK,wBAAwB,GAAG,CAC9B,KAAK,EAAE,GAAG,KACP,CAAC,OAAO,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG;IACxB,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;IAC5C,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;CAC7C,CAAC;AAIF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,WAAW,KAAG,IAEzD,CAAC;AAuBF,eAAO,MAAM,gBAAgB,QAAO,OAKnC,CAAC;AAUF,eAAO,MAAM,oBAAoB,EAAE,wBAMlC,CAAC;AAGF,eAAO,MAAM,oBAAoB,EAAE,wBAMlC,CAAC"}

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

@@ -0,0 +1,62 @@
+var pivotModuleCache;
+/**
+ * Register the pivot module explicitly. Required in environments where the
+ * fallback dynamic `require("@rowsncolumns/pivot/server")` cannot resolve at
+ * runtime: bun --compile single-file binaries, pure Node ESM, edge runtimes.
+ *
+ * Call once at startup, before invoking pivot operations:
+ *
+ * ```ts
+ * import * as pivotServer from "@rowsncolumns/pivot/server";
+ * import { registerPivotModule } from "@rowsncolumns/spreadsheet-state/server";
+ *
+ * registerPivotModule(pivotServer);
+ * ```
+ */
+export var registerPivotModule = function (module) {
+    pivotModuleCache = module;
+};
+var loadPivotModule = function () {
+    if (pivotModuleCache !== undefined) {
+        return pivotModuleCache;
+    }
+    pivotModuleCache = null;
+    if (typeof require !== "function") {
+        return pivotModuleCache;
+    }
+    try {
+        var requireFunc = require;
+        pivotModuleCache = requireFunc("@rowsncolumns/pivot/server");
+    }
+    catch (_a) {
+        pivotModuleCache = null;
+    }
+    return pivotModuleCache;
+};
+// Helper function to check if pivot are available
+export var isPivotAvailable = function () {
+    var pivotModule = loadPivotModule();
+    return Boolean((pivotModule === null || pivotModule === void 0 ? void 0 : pivotModule.createPivotTable) && (pivotModule === null || pivotModule === void 0 ? void 0 : pivotModule.deletePivotTable));
+};
+// Helper function to throw error when pivot are not available
+var throwPivotNotAvailable = function (operation) {
+    throw new Error("Pivot ".concat(operation, " operation requires the @rowsncolumns/pivot package. Install it (npm install @rowsncolumns/pivot) or register it explicitly via registerPivotModule(import(\"@rowsncolumns/pivot/server\")) at startup \u2014 required in bun --compile binaries and pure Node ESM where dynamic require fails."));
+};
+// Exported pivot functions with availability checks
+export var safeCreatePivotTable = function (props) {
+    var _a;
+    var createPivotTable = (_a = loadPivotModule()) === null || _a === void 0 ? void 0 : _a.createPivotTable;
+    if (!createPivotTable) {
+        throwPivotNotAvailable("create");
+    }
+    return createPivotTable(props);
+};
+// Exported pivot functions with availability checks
+export var safeDeletePivotTable = function (props) {
+    var _a;
+    var deletePivotTable = (_a = loadPivotModule()) === null || _a === void 0 ? void 0 : _a.deletePivotTable;
+    if (!deletePivotTable) {
+        throwPivotNotAvailable("delete");
+    }
+    return deletePivotTable(props);
+};

package/dist/cjs/interface/remove-duplicates.d.ts

@@ -0,0 +1,11 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { UseOnRemoveDuplicatesProps } from "../hooks/use-on-remove-duplicates";
+export type RemoveDuplicatesResult = {
+    /** Number of duplicate rows found and removed */
+    duplicatesRemoved: number;
+    /** Number of unique rows that remain */
+    uniqueRemaining: number;
+};
+export declare const removeDuplicates: <T extends CellData>({ getFormattedValue, onChangeSheetData, enqueueCalculation, createHistory, }: UseOnRemoveDuplicatesProps<T>) => (sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[]) => RemoveDuplicatesResult;
+//# sourceMappingURL=remove-duplicates.d.ts.map

package/dist/cjs/interface/remove-duplicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-duplicates.d.ts","sourceRoot":"","sources":["../../../interface/remove-duplicates.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,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAGpF,MAAM,MAAM,sBAAsB,GAAG;IACnC,iDAAiD;IACjD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,8EAKlD,0BAA0B,CAAC,CAAC,CAAC,MAE5B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,aAAa,aAAa,CAAC,mBAAmB,CAAC,EAAE,KAChD,sBA0JJ,CAAC"}

package/dist/cjs/interface/remove-duplicates.js

@@ -0,0 +1,132 @@
+import { __read, __values } from "tslib";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+export var removeDuplicates = function (_a) {
+    var getFormattedValue = _a.getFormattedValue, onChangeSheetData = _a.onChangeSheetData, enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory;
+    return function (sheetId, activeCell, selections) {
+        var e_1, _a;
+        var finalSelections = (selections === null || selections === void 0 ? void 0 : selections.length)
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        var saveHistory = createHistory();
+        var recalcCells = new Map();
+        var seenRows = new Set();
+        var duplicateRows = new Set();
+        try {
+            // First pass: collect all row data and identify duplicates
+            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;
+                for (var rowIndex = sel.range.startRowIndex; rowIndex <= sel.range.endRowIndex; rowIndex++) {
+                    var rowValues = [];
+                    for (var columnIndex = sel.range.startColumnIndex; columnIndex <= sel.range.endColumnIndex; columnIndex++) {
+                        var value = getFormattedValue(sheetId, rowIndex, columnIndex);
+                        rowValues.push(value !== null && value !== void 0 ? value : "");
+                    }
+                    // Create a key for this row based on all its values
+                    var rowKey = JSON.stringify(rowValues);
+                    if (seenRows.has(rowKey)) {
+                        // This is a duplicate row
+                        duplicateRows.add(rowIndex);
+                    }
+                    else {
+                        // First occurrence of this row
+                        seenRows.add(rowKey);
+                    }
+                }
+            }
+        }
+        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; }
+        }
+        var result = {
+            duplicatesRemoved: duplicateRows.size,
+            uniqueRemaining: seenRows.size,
+        };
+        // If no duplicates found, return early
+        if (duplicateRows.size === 0) {
+            return result;
+        }
+        var markDirty = function (rowIndex, columnIndex) {
+            // Track for recalculation
+            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                rowIndex: rowIndex,
+                columnIndex: columnIndex,
+                sheetId: sheetId,
+            });
+            // Enqueue calculation
+            enqueueCalculation({
+                type: "dirty",
+                position: {
+                    sheetId: sheetId,
+                    rowIndex: rowIndex,
+                    columnIndex: columnIndex,
+                },
+            });
+        };
+        // Second pass: delete the duplicate rows and shift the remaining rows up
+        // within the selection, like Excel's Remove Duplicates
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_2, _a;
+                var _b, _c, _d;
+                try {
+                    for (var finalSelections_2 = __values(finalSelections), finalSelections_2_1 = finalSelections_2.next(); !finalSelections_2_1.done; finalSelections_2_1 = finalSelections_2.next()) {
+                        var sel = finalSelections_2_1.value;
+                        var _e = sel.range, startRowIndex = _e.startRowIndex, endRowIndex = _e.endRowIndex, startColumnIndex = _e.startColumnIndex, endColumnIndex = _e.endColumnIndex;
+                        // Compact surviving rows towards the top of the selection
+                        var writeRowIndex = startRowIndex;
+                        for (var rowIndex = startRowIndex; rowIndex <= endRowIndex; rowIndex++) {
+                            // Skip rows that are duplicates — they get overwritten by the
+                            // rows below shifting up
+                            if (duplicateRows.has(rowIndex)) {
+                                continue;
+                            }
+                            if (writeRowIndex !== rowIndex) {
+                                var currentSheet = createSheetDraft(draft, sheetId, writeRowIndex);
+                                for (var columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                                    // Move the cell (value and formatting) up
+                                    currentSheet[writeRowIndex].values[columnIndex] =
+                                        (_d = (_c = (_b = draft[sheetId]) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex];
+                                    markDirty(writeRowIndex, columnIndex);
+                                }
+                            }
+                            writeRowIndex++;
+                        }
+                        // Clear the rows vacated at the bottom of the selection —
+                        // the rows were deleted, so the cells become empty like in Excel
+                        for (; writeRowIndex <= endRowIndex; writeRowIndex++) {
+                            var currentSheet = createSheetDraft(draft, sheetId, writeRowIndex);
+                            for (var columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                                currentSheet[writeRowIndex].values[columnIndex] = undefined;
+                                markDirty(writeRowIndex, columnIndex);
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (finalSelections_2_1 && !finalSelections_2_1.done && (_a = finalSelections_2.return)) _a.call(finalSelections_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: activeCell, redo: activeCell },
+                selections: { undo: selections, redo: selections },
+                sheetId: { undo: sheetId, redo: undefined },
+            });
+            return nextState;
+        });
+        return result;
+    };
+};

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

@@ -0,0 +1,4 @@
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseOnTableProps } from "../hooks/use-on-table";
+export declare const removeTable: <T extends CellData, S extends Sheet>({ onChangeTables, onChangeSheets, createHistory, getDependents, enqueueCalculation, }: Pick<UseOnTableProps<T, S>, "onChangeTables" | "onChangeSheets" | "getDependents" | "enqueueCalculation" | "createHistory">) => (tableView: TableView) => void;
+//# sourceMappingURL=remove-table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"remove-table.d.ts","sourceRoot":"","sources":["../../../interface/remove-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAG5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,uFAM9D,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,gBAAgB,GAChB,gBAAgB,GAChB,eAAe,GACf,oBAAoB,GACpB,eAAe,CAClB,MACS,WAAW,SAAS,SAmE7B,CAAC"}

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

@@ -0,0 +1,53 @@
+import { __read } from "tslib";
+import { produceWithPatches } from "immer";
+export var removeTable = function (_a) {
+    var onChangeTables = _a.onChangeTables, onChangeSheets = _a.onChangeSheets, createHistory = _a.createHistory, getDependents = _a.getDependents, enqueueCalculation = _a.enqueueCalculation;
+    return function (tableView) {
+        var saveHistory = createHistory();
+        // Move tables if necessary
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var tableIndex = draft.findIndex(function (table) { return table.id == tableView.id; } // Accept both string and number
+                );
+                if (tableIndex !== -1) {
+                    draft.splice(tableIndex, 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Mark table cells as dirty
+            // const recalcCells = markTableAsDirty(
+            //   tableView.sheetId,
+            //   tableView.range,
+            //   getDependents,
+            //   enqueueCalculation
+            // );
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+                // recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Remove hidden columns if user is removing table
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === tableView.sheetId; });
+                if (sheet && tableView) {
+                    if (!sheet.rowMetadata) {
+                        sheet.rowMetadata = [];
+                    }
+                    var range = tableView.range;
+                    for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                        if ((_a = sheet.rowMetadata[rowIndex]) === null || _a === void 0 ? void 0 : _a.hiddenByFilter) {
+                            sheet.rowMetadata[rowIndex].hiddenByFilter = false;
+                        }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save to history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/interface/resize-utils.d.ts

@@ -0,0 +1,18 @@
+import type { AXIS, CellData, Sheet } from "@rowsncolumns/spreadsheet";
+type AutoResizeRowsConfig<T extends CellData, S extends Sheet> = {
+    sheet: S;
+    sheetId: number;
+    columnIndexes: number[];
+    dimension: number;
+    getCellDimensions?: (sheetId: number, rowIndex: number, columnIndex: number, axis: AXIS, options?: {
+        boundedWidth?: number;
+    }) => {
+        width?: number;
+        height?: number;
+    } | undefined;
+    getRowHeight?: (sheetId: number, rowIndex: number, shouldSkipColumn?: (columnIndex: number) => boolean) => number | undefined;
+    isMergedCell?: (sheetId: number, rowIndex: number, columnIndex: number) => boolean | undefined;
+};
+export declare const autoResizeRows: <T extends CellData, S extends Sheet>({ sheet, sheetId, columnIndexes, dimension, getCellDimensions, getRowHeight, isMergedCell, }: AutoResizeRowsConfig<T, S>) => void;
+export type { AutoResizeRowsConfig, };
+//# sourceMappingURL=resize-utils.d.ts.map

package/dist/cjs/interface/resize-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-utils.d.ts","sourceRoot":"","sources":["../../../interface/resize-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAGvE,KAAK,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC/D,KAAK,EAAE,CAAC,CAAC;IACT,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,CAClB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,KAChC;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IACrD,YAAY,CAAC,EAAE,CACb,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,KAChD,MAAM,GAAG,SAAS,CAAC;IACxB,YAAY,CAAC,EAAE,CACb,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,OAAO,GAAG,SAAS,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,8FAQjE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,SA8C5B,CAAC;AAEF,YAAY,EACV,oBAAoB,GACrB,CAAC"}