@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/utils/frozen-sort.js

@@ -0,0 +1,28 @@
+import { __read, __spreadArray } from "tslib";
+/**
+ * Sorts rows while keeping frozen rows at the top segment. Frozen rows are
+ * sorted independently from the rest of the rows to mimic Excel's behaviour
+ * where panes above the frozen line get reordered within their own segment.
+ */
+export var reorderRowsByFrozenState = function (rowValues, rowIndexMap, frozenRowCount, comparator) {
+    if (!frozenRowCount) {
+        rowValues.sort(comparator);
+        return;
+    }
+    var entries = rowValues.map(function (values, idx) {
+        var _a;
+        return ({
+            values: values,
+            rowIndex: (_a = rowIndexMap[idx]) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER,
+        });
+    });
+    var sortEntries = function (items) {
+        return items
+            .sort(function (left, right) { return comparator(left.values, right.values); })
+            .map(function (entry) { return entry.values; });
+    };
+    var frozenEntries = entries.filter(function (entry) { return entry.rowIndex <= frozenRowCount; });
+    var nonFrozenEntries = entries.filter(function (entry) { return entry.rowIndex > frozenRowCount; });
+    var sortedRows = __spreadArray(__spreadArray([], __read(sortEntries(frozenEntries)), false), __read(sortEntries(nonFrozenEntries)), false);
+    rowValues.splice.apply(rowValues, __spreadArray([0, rowValues.length], __read(sortedRows), false));
+};

package/dist/cjs/hooks/utils/sort-rows.d.ts

@@ -0,0 +1,32 @@
+import type { SortOrder } from "@rowsncolumns/spreadsheet";
+export type RowSortEntry = {
+    rowIndex: number;
+    sortValues: unknown[];
+};
+/**
+ * Per-dimension sort specification consumed by the row sorter.
+ * `sortBy` defaults to "value" (numeric/text/boolean comparison via the
+ * collator). Color and icon modes surface the matching cells to the top
+ * (ASCENDING) or bottom (DESCENDING).
+ */
+export type DimensionSortSpec = {
+    sortOrder: SortOrder;
+    sortBy?: "value" | "cellColor" | "fontColor" | "icon" | null;
+    /** When sortBy is cellColor/fontColor, the color to surface (hex). */
+    sortColor?: string | null;
+    /** When sortBy is icon, the (iconSet, iconId) to surface. */
+    sortIcon?: {
+        iconSet: string;
+        iconId: number;
+    } | null;
+    /** Custom sort order. Strings define the position; case-insensitive. */
+    customList?: string[] | null;
+};
+export declare const sortRowEntriesByFrozenState: (rowEntries: RowSortEntry[], frozenRowCount: number, 
+/**
+ * Sort specifications per dimension. Accepts either the legacy
+ * `SortOrder[]` array (back-compat) or the richer `DimensionSortSpec[]`
+ * with `sortBy`/`sortColor`/`sortIcon`/`customList`.
+ */
+sortSpecs: SortOrder[] | DimensionSortSpec[]) => RowSortEntry[];
+//# sourceMappingURL=sort-rows.d.ts.map

package/dist/cjs/hooks/utils/sort-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-rows.d.ts","sourceRoot":"","sources":["../../../../hooks/utils/sort-rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAI3D,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,GAAG,IAAI,CAAC;IAC7D,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,6DAA6D;IAC7D,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACtD,wEAAwE;IACxE,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CAC9B,CAAC;AA8HF,eAAO,MAAM,2BAA2B,GACtC,YAAY,YAAY,EAAE,EAC1B,gBAAgB,MAAM;AACtB;;;;GAIG;AACH,WAAW,SAAS,EAAE,GAAG,iBAAiB,EAAE,mBAuB7C,CAAC"}

package/dist/cjs/hooks/utils/sort-rows.js

@@ -0,0 +1,113 @@
+import { __read, __spreadArray } from "tslib";
+import { cellValueSorter } from "../../api/sort";
+var toSortableValue = function (value) {
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        value == null) {
+        return value;
+    }
+    return String(value);
+};
+/**
+ * Case-insensitive string equality for color matching. Sort entries are
+ * already theme-resolved by the caller (via `getStringifiedColor`), so
+ * we don't need to handle theme-indexed objects or ARGB stripping here.
+ */
+var sameColor = function (left, right) {
+    return typeof left === "string" && left.toLowerCase() === right.toLowerCase();
+};
+/**
+ * "Surface to the top" comparator. When ASCENDING, cells matching the
+ * target go first; ties between matching/non-matching cells are kept
+ * stable. DESCENDING flips the direction.
+ */
+var surfaceMatchSorter = function (leftMatches, rightMatches, sortOrder) {
+    if (leftMatches === rightMatches)
+        return 0;
+    var direction = sortOrder === "ASCENDING" ? -1 : 1;
+    return leftMatches ? direction : -direction;
+};
+/** Custom-list comparator. Values not in the list sort last. */
+var customListSorter = function (left, right, list, sortOrder) {
+    var indexOf = function (v) {
+        if (v == null)
+            return -1;
+        var s = String(v).toLowerCase();
+        return list.findIndex(function (entry) { return entry.toLowerCase() === s; });
+    };
+    var li = indexOf(left);
+    var ri = indexOf(right);
+    // Values absent from the list go to the end regardless of direction.
+    if (li === -1 && ri === -1)
+        return 0;
+    if (li === -1)
+        return 1;
+    if (ri === -1)
+        return -1;
+    var diff = li - ri;
+    return (sortOrder === "ASCENDING" ? 1 : -1) * Math.sign(diff);
+};
+var sortValueOne = function (left, right, spec) {
+    var _a;
+    var sortOrder = spec.sortOrder;
+    if (spec.sortBy === "cellColor" || spec.sortBy === "fontColor") {
+        var target = spec.sortColor;
+        if (!target)
+            return 0;
+        return surfaceMatchSorter(sameColor(left, target), sameColor(right, target), sortOrder);
+    }
+    if (spec.sortBy === "icon") {
+        var target_1 = spec.sortIcon;
+        if (!target_1)
+            return 0;
+        var isMatch = function (val) {
+            var icon = val;
+            return (icon === null || icon === void 0 ? void 0 : icon.iconSet) === target_1.iconSet && (icon === null || icon === void 0 ? void 0 : icon.iconId) === target_1.iconId;
+        };
+        return surfaceMatchSorter(isMatch(left), isMatch(right), sortOrder);
+    }
+    if ((_a = spec.customList) === null || _a === void 0 ? void 0 : _a.length) {
+        return customListSorter(toSortableValue(left), toSortableValue(right), spec.customList, sortOrder);
+    }
+    return cellValueSorter(toSortableValue(left), toSortableValue(right), sortOrder);
+};
+/** Normalize the legacy `SortOrder[]` shape to `DimensionSortSpec[]`. */
+var normalizeSpecs = function (specs) {
+    return specs.map(function (s) { return (typeof s === "string" ? { sortOrder: s } : s); });
+};
+var compareSortValues = function (leftValues, rightValues, specs) {
+    var _a, _b;
+    var columnLength = Math.max(leftValues.length, rightValues.length);
+    for (var i = 0; i < columnLength; i++) {
+        var spec = (_b = (_a = specs[i]) !== null && _a !== void 0 ? _a : specs[0]) !== null && _b !== void 0 ? _b : { sortOrder: "ASCENDING" };
+        var diff = sortValueOne(leftValues[i], rightValues[i], spec);
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    return 0;
+};
+export var sortRowEntriesByFrozenState = function (rowEntries, frozenRowCount, 
+/**
+ * Sort specifications per dimension. Accepts either the legacy
+ * `SortOrder[]` array (back-compat) or the richer `DimensionSortSpec[]`
+ * with `sortBy`/`sortColor`/`sortIcon`/`customList`.
+ */
+sortSpecs) {
+    var normalized = normalizeSpecs(sortSpecs);
+    if (!frozenRowCount) {
+        rowEntries.sort(function (left, right) {
+            return compareSortValues(left.sortValues, right.sortValues, normalized);
+        });
+        return rowEntries;
+    }
+    var frozenEntries = rowEntries.filter(function (entry) { return entry.rowIndex <= frozenRowCount; });
+    var nonFrozenEntries = rowEntries.filter(function (entry) { return entry.rowIndex > frozenRowCount; });
+    var comparator = function (left, right) {
+        return compareSortValues(left.sortValues, right.sortValues, normalized);
+    };
+    frozenEntries.sort(comparator);
+    nonFrozenEntries.sort(comparator);
+    return __spreadArray(__spreadArray([], __read(frozenEntries), false), __read(nonFrozenEntries), false);
+};

package/dist/cjs/index.d.ts

@@ -0,0 +1,38 @@
+export * from "./generated-names";
+export * from "./hooks/use-spreadsheet-state";
+export * from "./hooks/use-on-copy";
+export { generateDataFromClipboard, pickFormatting, pickFormula, pickValue, transpose, } from "./api/copy-paste";
+export * from "./hooks/use-calculation";
+export * from "./hooks/use-on-change-batch-stream";
+export * from "./hooks/use-on-trace-dependents-precedents";
+export * from "./hooks/use-structured-reference";
+export * from "./hooks/use-undo-redo";
+export * from "./hooks/use-async-datasource";
+export * from "./hooks/use-search";
+export * from "./hooks/use-calculation-initialize";
+export * from "./hooks/use-comments";
+export * from "./components";
+export * from "./api/datatype";
+export * from "./sheet-cell";
+export { useSubscribeToSheet, useSubscribeToMultipleRanges, } from "./hooks/use-sheet-observer";
+export * from "./helpers";
+export * from "./api/fill";
+export * from "./api/immer-utils";
+export * from "./api/range";
+export * from "./atoms";
+export * from "./api/formula";
+export * from "./types";
+export * from "./commands";
+export type { ClearType } from "./interface/delete-cells";
+export * from "./hooks/use-cellxfs-registry";
+export * from "./hooks/use-ss-registry";
+export * from "./hooks/use-sheet-properties";
+export * from "./hooks/use-on-remove-duplicates";
+export * from "./hooks/use-on-locale-change";
+export * from "./hooks/use-on-request-resize";
+export * from "./hooks/use-on-request-edit-table";
+export * from "./hooks/use-on-request-delete-sheet";
+export * from "./hooks/use-on-request-data-validation";
+export * from "./hooks/use-on-request-define-named-range";
+export * from "./hooks/use-on-request-update-named-range";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC;AACpC,OAAO,EACL,yBAAyB,EACzB,cAAc,EACd,WAAW,EACX,SAAS,EACT,SAAS,GACV,MAAM,kBAAkB,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oCAAoC,CAAC;AACnD,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,mBAAmB,EACnB,4BAA4B,GAC7B,MAAM,4BAA4B,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,YAAY,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAG7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,wCAAwC,CAAC;AACvD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,2CAA2C,CAAC"}

package/dist/cjs/index.js

@@ -0,0 +1,39 @@
+export * from "./generated-names";
+export * from "./hooks/use-spreadsheet-state";
+export * from "./hooks/use-on-copy";
+export { generateDataFromClipboard, pickFormatting, pickFormula, pickValue, transpose, } from "./api/copy-paste";
+export * from "./hooks/use-calculation";
+export * from "./hooks/use-on-change-batch-stream";
+export * from "./hooks/use-on-trace-dependents-precedents";
+export * from "./hooks/use-structured-reference";
+export * from "./hooks/use-undo-redo";
+export * from "./hooks/use-async-datasource";
+export * from "./hooks/use-search";
+export * from "./hooks/use-calculation-initialize";
+export * from "./hooks/use-comments";
+export * from "./components";
+export * from "./api/datatype";
+export * from "./sheet-cell";
+export { useSubscribeToSheet, useSubscribeToMultipleRanges, } from "./hooks/use-sheet-observer";
+export * from "./helpers";
+export * from "./api/fill";
+export * from "./api/immer-utils";
+export * from "./api/range";
+export * from "./atoms";
+export * from "./api/formula";
+export * from "./types";
+export * from "./commands";
+// Register
+export * from "./hooks/use-cellxfs-registry";
+export * from "./hooks/use-ss-registry";
+export * from "./hooks/use-sheet-properties";
+export * from "./hooks/use-on-remove-duplicates";
+export * from "./hooks/use-on-locale-change";
+// Dialog-opener hooks external engine chrome bridges to (they write the payload
+// atoms the dialog hosts read; nothing else exports them).
+export * from "./hooks/use-on-request-resize";
+export * from "./hooks/use-on-request-edit-table";
+export * from "./hooks/use-on-request-delete-sheet";
+export * from "./hooks/use-on-request-data-validation";
+export * from "./hooks/use-on-request-define-named-range";
+export * from "./hooks/use-on-request-update-named-range";

package/dist/cjs/interface/apply-fill.d.ts

@@ -0,0 +1,6 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { AutoFillType } from "../api/fill";
+import type { UseOnFillProps } from "../hooks/use-on-fill";
+export declare const applyFill: <T extends CellData, S extends Sheet>({ locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getCellData, getEffectiveValue, getFormattedValue, getAutoFillValues, getSheetName, enqueueCalculation, enqueueStructureChange, onChangeSheetData, createHistory, onChangeDataValidations, }: UseOnFillProps<T, S>) => (sheetId: number, activeCell: CellInterface, fillSelection: SelectionArea, selections: SelectionArea<SelectionAttributes>[], fillableSelections?: SelectionArea<SelectionAttributes>[], fillType?: AutoFillType) => Promise<void>;
+//# sourceMappingURL=apply-fill.d.ts.map

package/dist/cjs/interface/apply-fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-fill.d.ts","sourceRoot":"","sources":["../../../interface/apply-fill.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG/E,OAAO,KAAK,EACV,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAU3D,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sQAe5D,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAGnB,SAAS,MAAM,EAEf,YAAY,aAAa,EAEzB,eAAe,aAAa,EAE5B,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,qBAAqB,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAEzD,WAAW,YAAY,kBA0Q1B,CAAC"}

package/dist/cjs/interface/apply-fill.js

@@ -0,0 +1,203 @@
+import { __awaiter, __generator, __read } from "tslib";
+import { Direction } from "@rowsncolumns/common-types";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { defaultCellCoords, defaultSheetId, SheetCell } from "../sheet-cell";
+import { getFillDirection } from "./../api/selection";
+import { collectDataValidationTarget, extendDataValidationRanges, } from "./data-validation-utils";
+export var applyFill = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getDataValidationById = _a.getDataValidationById, getCellData = _a.getCellData, getEffectiveValue = _a.getEffectiveValue, getFormattedValue = _a.getFormattedValue, getAutoFillValues = _a.getAutoFillValues, getSheetName = _a.getSheetName, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory, onChangeDataValidations = _a.onChangeDataValidations;
+    return function (
+    // Active sheet ID
+    sheetId, 
+    // Active cell
+    activeCell, 
+    // Selections including the current selection that will be filled
+    fillSelection, 
+    // Current selections of the user
+    selections, fillableSelections, 
+    // Fill type - if not specified, will auto-detect
+    fillType) { return __awaiter(void 0, void 0, void 0, function () {
+        var finalSelections, selection, saveHistory, fillBounds, direction, recalcCells, dataValidationTargets, fillValues, sheetCell, getFillValue;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    finalSelections = selections.length
+                        ? selections
+                        : selectionFromActiveCell(activeCell);
+                    selection = finalSelections[finalSelections.length - 1];
+                    saveHistory = createHistory();
+                    fillBounds = fillSelection.range;
+                    direction = getFillDirection(fillSelection, selection);
+                    recalcCells = new Map();
+                    dataValidationTargets = new Map();
+                    return [4 /*yield*/, getAutoFillValues({
+                            sheetId: sheetId,
+                            direction: direction,
+                            fillBounds: fillBounds,
+                            getCellData: getCellData,
+                            getEffectiveValue: getEffectiveValue,
+                            getFormattedValue: getFormattedValue,
+                            getSheetName: getSheetName,
+                            selection: selection,
+                            locale: locale,
+                            cellXfsRegistry: cellXfsRegistry,
+                            getDataValidationById: getDataValidationById,
+                            fillType: fillType,
+                        })];
+                case 1:
+                    fillValues = _a.sent();
+                    sheetCell = new SheetCell(defaultSheetId, defaultCellCoords, undefined, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+                    getFillValue = function (rowIndex, columnIndex) {
+                        var fillValue = fillValues[rowIndex][columnIndex];
+                        if (typeof fillValue !== "object") {
+                            sheetCell.setUserEnteredValue(fillValue);
+                            sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.registerCell(sheetCell);
+                            var newCellData = sheetCell.getCellData();
+                            return newCellData;
+                        }
+                        return fillValue;
+                    };
+                    // Fill writes through `onChangeSheetData` directly. The calculator
+                    // only invalidates `rangeCache` for cells it recomputes, so the
+                    // freshly-filled positions stay cached until we tell it otherwise.
+                    // `fillBounds` is the union of source + filled area — exactly the
+                    // rectangle whose cached ranges could be stale.
+                    enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+                        kind: "invalidate-range",
+                        sheetId: sheetId,
+                        startRowIndex: fillBounds.startRowIndex,
+                        endRowIndex: fillBounds.endRowIndex,
+                        startColumnIndex: fillBounds.startColumnIndex,
+                        endColumnIndex: fillBounds.endColumnIndex,
+                    });
+                    // Copy sheetdata
+                    onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                        var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                            switch (direction) {
+                                case Direction.Down: {
+                                    var start = selection.range.endRowIndex + 1;
+                                    var end = fillBounds.endRowIndex;
+                                    var counter = 0;
+                                    for (var i = start; i <= end; i++) {
+                                        var rowIndex = selection.range.startRowIndex + counter;
+                                        if (rowIndex > selection.range.endRowIndex) {
+                                            counter = 0;
+                                            rowIndex = selection.range.startRowIndex;
+                                        }
+                                        var rollingRowIndex = i - start;
+                                        for (var columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                                            var rollingColumnIndex = columnIndex - selection.range.startColumnIndex;
+                                            var newSheet = createSheetDraft(draft, sheetId, i);
+                                            var newCellData = getFillValue(rollingRowIndex, rollingColumnIndex);
+                                            newSheet[i].values[columnIndex] = newCellData;
+                                            collectDataValidationTarget(dataValidationTargets, sheetId, i, columnIndex, newCellData);
+                                            enqueueCalculation({
+                                                position: { rowIndex: i, columnIndex: columnIndex, sheetId: sheetId },
+                                                type: "add",
+                                                force: true,
+                                            });
+                                            recalcCells.set(createSheetCellIdentifier(sheetId, i, columnIndex), { rowIndex: i, columnIndex: columnIndex, sheetId: sheetId, force: true });
+                                        }
+                                        counter++;
+                                    }
+                                    break;
+                                }
+                                case Direction.Up: {
+                                    var start = selection.range.startRowIndex - 1;
+                                    var end = fillBounds.startRowIndex;
+                                    for (var i = start; i >= end; i--) {
+                                        var rollingRowIndex = i - fillBounds.startRowIndex;
+                                        for (var columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                                            var rollingColumnIndex = columnIndex - selection.range.startColumnIndex;
+                                            var newSheet = createSheetDraft(draft, sheetId, i);
+                                            newSheet[i].values[columnIndex] = getFillValue(rollingRowIndex, rollingColumnIndex);
+                                            collectDataValidationTarget(dataValidationTargets, sheetId, i, columnIndex, newSheet[i].values[columnIndex]);
+                                            enqueueCalculation({
+                                                position: { rowIndex: i, columnIndex: columnIndex, sheetId: sheetId },
+                                                type: "add",
+                                                force: true,
+                                            });
+                                            recalcCells.set(createSheetCellIdentifier(sheetId, i, columnIndex), { rowIndex: i, columnIndex: columnIndex, sheetId: sheetId, force: true });
+                                        }
+                                    }
+                                    break;
+                                }
+                                case Direction.Right: {
+                                    for (var rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                                        var start = selection.range.endColumnIndex + 1;
+                                        var end = fillBounds.endColumnIndex;
+                                        var counter = 0;
+                                        var rollingRowIndex = rowIndex - selection.range.startRowIndex;
+                                        for (var j = start; j <= end; j++) {
+                                            var columnIndex = selection.range.startColumnIndex + counter;
+                                            if (columnIndex > selection.range.endColumnIndex) {
+                                                counter = 0;
+                                                columnIndex = selection.range.startColumnIndex;
+                                            }
+                                            var rollingColumnIndex = j - start;
+                                            var newSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                            newSheet[rowIndex].values[j] = getFillValue(rollingRowIndex, rollingColumnIndex);
+                                            collectDataValidationTarget(dataValidationTargets, sheetId, rowIndex, j, newSheet[rowIndex].values[j]);
+                                            enqueueCalculation({
+                                                position: { rowIndex: rowIndex, columnIndex: j, sheetId: sheetId },
+                                                type: "add",
+                                                force: true,
+                                            });
+                                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, j), { rowIndex: rowIndex, columnIndex: j, sheetId: sheetId, force: true });
+                                            counter++;
+                                        }
+                                    }
+                                    break;
+                                }
+                                case Direction.Left: {
+                                    for (var rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                                        var start = selection.range.startColumnIndex - 1;
+                                        var end = fillBounds.startColumnIndex;
+                                        var rollingRowIndex = rowIndex - selection.range.startRowIndex;
+                                        var counter = 0;
+                                        for (var j = start; j >= end; j--) {
+                                            var columnIndex = selection.range.endColumnIndex + counter;
+                                            if (columnIndex < selection.range.startColumnIndex) {
+                                                counter = 0;
+                                                columnIndex = selection.range.endColumnIndex;
+                                            }
+                                            var rollingColumnIndex = j - fillBounds.startColumnIndex;
+                                            var newSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                            newSheet[rowIndex].values[j] = getFillValue(rollingRowIndex, rollingColumnIndex);
+                                            collectDataValidationTarget(dataValidationTargets, sheetId, rowIndex, j, newSheet[rowIndex].values[j]);
+                                            enqueueCalculation({
+                                                position: { rowIndex: rowIndex, columnIndex: j, sheetId: sheetId },
+                                                type: "add",
+                                                force: true,
+                                            });
+                                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, j), { rowIndex: rowIndex, columnIndex: j, sheetId: sheetId, force: true });
+                                            counter--;
+                                        }
+                                    }
+                                    break;
+                                }
+                            }
+                        }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                        // Save history
+                        saveHistory({
+                            sheetData: { patches: patches, inversePatches: inversePatches },
+                            recalcCells: { undo: recalcCells, redo: recalcCells },
+                            sheetId: { undo: sheetId, redo: sheetId },
+                            activeCell: { undo: activeCell, redo: activeCell },
+                            selections: {
+                                undo: fillableSelections !== null && fillableSelections !== void 0 ? fillableSelections : selections,
+                                redo: [fillSelection],
+                            },
+                        });
+                        extendDataValidationRanges(dataValidationTargets, onChangeDataValidations, saveHistory);
+                        sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.getPatches(saveHistory);
+                        return nextState;
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+};

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

@@ -0,0 +1,4 @@
+import type { AXIS, CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnAutoResizeProps } from "../hooks/use-on-autoresize";
+export declare const autoResize: <T extends CellData, S extends Sheet>({ createHistory, getActiveCell, onChangeSheets, getColumnWidth, getRowHeight, getCellDimensions, isMergedCell, }: UseOnAutoResizeProps<T, S>) => (sheetId: number, indexes: number[], axis: AXIS) => void;
+//# sourceMappingURL=auto-resize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auto-resize.d.ts","sourceRoot":"","sources":["../../../interface/auto-resize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,QAAQ,EAER,KAAK,EACN,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGvE,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kHAQ7D,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,MACnB,SAAS,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,IAAI,SAuDvD,CAAC"}

package/dist/cjs/interface/auto-resize.js

@@ -0,0 +1,63 @@
+import { __read, __values } from "tslib";
+import { isNil } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { autoResizeRows } from "./resize-utils";
+export var autoResize = function (_a) {
+    var createHistory = _a.createHistory, getActiveCell = _a.getActiveCell, onChangeSheets = _a.onChangeSheets, getColumnWidth = _a.getColumnWidth, getRowHeight = _a.getRowHeight, getCellDimensions = _a.getCellDimensions, isMergedCell = _a.isMergedCell;
+    return function (sheetId, indexes, axis) {
+        var saveHistory = createHistory();
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    var metaData = axis === "x" ? "rowMetadata" : "columnMetadata";
+                    if (!sheet[metaData]) {
+                        sheet[metaData] = [];
+                    }
+                    try {
+                        for (var indexes_1 = __values(indexes), indexes_1_1 = indexes_1.next(); !indexes_1_1.done; indexes_1_1 = indexes_1.next()) {
+                            var index = indexes_1_1.value;
+                            var dimension = axis === "y"
+                                ? getColumnWidth === null || getColumnWidth === void 0 ? void 0 : getColumnWidth(sheetId, index, {
+                                    fallbackToDefaultIfEmpty: true,
+                                })
+                                : getRowHeight === null || getRowHeight === void 0 ? void 0 : getRowHeight(sheetId, index);
+                            if (!isNil(dimension)) {
+                                sheet[metaData][index] = {
+                                    size: dimension,
+                                    resizedByUser: false,
+                                };
+                                if (axis === "y") {
+                                    autoResizeRows({
+                                        sheet: sheet,
+                                        sheetId: sheetId,
+                                        columnIndexes: [index],
+                                        dimension: dimension,
+                                        getCellDimensions: getCellDimensions,
+                                        getRowHeight: getRowHeight,
+                                        isMergedCell: isMergedCell,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (indexes_1_1 && !indexes_1_1.done && (_a = indexes_1.return)) _a.call(indexes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save to history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/interface/calculation-interface.d.ts

@@ -0,0 +1,67 @@
+import type { Worker as NodeWorker } from "node:worker_threads";
+import { type CalculationPrimitive } from "@rowsncolumns/calculation-worker/server";
+import type { CellFormat, IterativeCalculationOptions, StructuredResult } from "@rowsncolumns/common-types";
+import type { CellCoordinate, CellCoordinateRange } from "@rowsncolumns/dag";
+import type { NamedRange, TableView } from "@rowsncolumns/spreadsheet";
+import type { CalculationOperation, CalculationResult, StructureChange } from "../hooks/use-calculation";
+type CalculationResultEntry = [
+    position: CellCoordinate,
+    result: CalculationResult,
+    formatting?: CellFormat
+];
+export type CalculationInterfaceOptions = {
+    locale?: string;
+    iterativeCalculation?: IterativeCalculationOptions;
+    createWorker?: () => Worker | NodeWorker;
+    clientOnlyFunctionPattern?: RegExp;
+    getSheetName(sheetId: number): string;
+    getSheetId(sheetName: string): number | undefined;
+    getSheets(): Array<{
+        sheetId: number;
+        title: string;
+    }>;
+    getTables(): TableView[];
+    getNamedRanges(): NamedRange[];
+    getFinalUserEnteredValue(position: CellCoordinate): string | undefined;
+    getEffectiveValue(sheetId: number, rowIndex: number, columnIndex: number, property?: string): CalculationPrimitive;
+    getEffectiveStructuredValue?(structuredValue: StructuredResult, property?: keyof StructuredResult): CalculationPrimitive | undefined;
+    onResults(results: CalculationResultEntry[]): void;
+    onBeginCalculation?(dirtyCells: CellCoordinate[]): void;
+};
+export declare class CalculationInterface {
+    private readonly options;
+    private readonly graph;
+    private readonly workerClient;
+    private operationQueue;
+    private graphOperationQueue;
+    private flushScheduled;
+    private graphFlushScheduled;
+    private metadataDirty;
+    private lastMetadataSignature;
+    private pendingFlush;
+    constructor(options: CalculationInterfaceOptions);
+    enqueueCalculation: (operation: CalculationOperation) => void;
+    enqueueGraphOperation: (operation: CalculationOperation) => void;
+    enqueueStructureChange: (_change: StructureChange) => void;
+    getDependents(source: CellCoordinate | CellCoordinateRange): (import("@rowsncolumns/dag").CellNode | import("@rowsncolumns/dag").StaticNode)[];
+    getPrecedents(source: CellCoordinate | CellCoordinateRange): (import("@rowsncolumns/dag").CellNode | import("@rowsncolumns/dag").StaticNode | import("@rowsncolumns/dag").CellRangeNode)[];
+    getNodes(): Map<string, import("@rowsncolumns/dag").CellNode | import("@rowsncolumns/dag").StaticNode | import("@rowsncolumns/dag").CellRangeNode>;
+    getNodesInSheet(sheetId: number): ReadonlyMap<string, import("@rowsncolumns/dag").CellNode | import("@rowsncolumns/dag").CellRangeNode> | undefined;
+    markMetadataDirty: () => void;
+    flush(): Promise<void>;
+    flushWithResults(): Promise<CalculationResultEntry[]>;
+    calculate(operations: CalculationOperation[]): Promise<CalculationResultEntry[]>;
+    rebuildGraph(operations: CalculationOperation[]): void;
+    dispose(): void;
+    private scheduleFlush;
+    private scheduleGraphFlush;
+    private buildWorkerMetadata;
+    private buildMetadataSignature;
+    private ensureWorkerMetadata;
+    private isClientOnlyFormula;
+    private executeOperations;
+    private createDefaultWorker;
+    private ensureWorker;
+}
+export {};
+//# sourceMappingURL=calculation-interface.d.ts.map

package/dist/cjs/interface/calculation-interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculation-interface.d.ts","sourceRoot":"","sources":["../../../interface/calculation-interface.ts"],"names":[],"mappings":"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"}