@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-on-ungroup-columns.js

@@ -0,0 +1,57 @@
+import { __read, __spreadArray, __values } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { contiguousSpans } from "../api/outline";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export var useOnUngroupColumns = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, columnIndexes) {
+        if (!canEditSheet(sheetId) || columnIndexes.length === 0)
+            return;
+        var saveHistory = createHistory();
+        var sorted = __spreadArray([], __read(columnIndexes), false).sort(function (a, b) { return a - b; });
+        var spans = contiguousSpans(sorted);
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var _b;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (!(sheet === null || sheet === void 0 ? void 0 : sheet.columnMetadata))
+                    return;
+                try {
+                    for (var spans_1 = __values(spans), spans_1_1 = spans_1.next(); !spans_1_1.done; spans_1_1 = spans_1.next()) {
+                        var _c = spans_1_1.value, start = _c.start, end = _c.end;
+                        for (var c = start; c <= end; c++) {
+                            var meta = sheet.columnMetadata[c];
+                            if (!meta)
+                                continue;
+                            var current = (_b = meta.outlineLevel) !== null && _b !== void 0 ? _b : 0;
+                            if (current <= 0)
+                                continue;
+                            var next = current - 1;
+                            if (next === 0) {
+                                delete meta.outlineLevel;
+                                delete meta.collapsed;
+                                delete meta.hiddenByGroup;
+                            }
+                            else {
+                                meta.outlineLevel = next;
+                            }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (spans_1_1 && !spans_1_1.done && (_a = spans_1.return)) _a.call(spans_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "ungroup-columns", sheetId: sheetId, columnIndexes: columnIndexes });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

package/dist/cjs/hooks/use-on-ungroup-rows.d.ts

@@ -0,0 +1,17 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnUngroupRowsProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onCommand?: OnCommand;
+};
+/**
+ * Ungroup a contiguous run of rows. Decrements each row's
+ * `outlineLevel` by one; when the level reaches zero the row is also
+ * cleared of `collapsed` and `hiddenByGroup` (no parent left to
+ * collapse it). Matches Excel's Data → Ungroup → Rows command.
+ */
+export declare const useOnUngroupRows: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onCommand, }: UseOnUngroupRowsProps<T, S>) => (sheetId: number, rowIndexes: number[]) => void;
+//# sourceMappingURL=use-on-ungroup-rows.d.ts.map

package/dist/cjs/hooks/use-on-ungroup-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-ungroup-rows.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-ungroup-rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACvE,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAInE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,eAGhB,MAAM,cAAc,MAAM,EAAE,SAsCzC,CAAC"}

package/dist/cjs/hooks/use-on-ungroup-rows.js

@@ -0,0 +1,63 @@
+import { __read, __spreadArray, __values } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { contiguousSpans } from "../api/outline";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+/**
+ * Ungroup a contiguous run of rows. Decrements each row's
+ * `outlineLevel` by one; when the level reaches zero the row is also
+ * cleared of `collapsed` and `hiddenByGroup` (no parent left to
+ * collapse it). Matches Excel's Data → Ungroup → Rows command.
+ */
+export var useOnUngroupRows = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, rowIndexes) {
+        if (!canEditSheet(sheetId) || rowIndexes.length === 0)
+            return;
+        var saveHistory = createHistory();
+        var sorted = __spreadArray([], __read(rowIndexes), false).sort(function (a, b) { return a - b; });
+        var spans = contiguousSpans(sorted);
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var _b;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (!(sheet === null || sheet === void 0 ? void 0 : sheet.rowMetadata))
+                    return;
+                try {
+                    for (var spans_1 = __values(spans), spans_1_1 = spans_1.next(); !spans_1_1.done; spans_1_1 = spans_1.next()) {
+                        var _c = spans_1_1.value, start = _c.start, end = _c.end;
+                        for (var r = start; r <= end; r++) {
+                            var meta = sheet.rowMetadata[r];
+                            if (!meta)
+                                continue;
+                            var current = (_b = meta.outlineLevel) !== null && _b !== void 0 ? _b : 0;
+                            if (current <= 0)
+                                continue;
+                            var next = current - 1;
+                            if (next === 0) {
+                                delete meta.outlineLevel;
+                                delete meta.collapsed;
+                                delete meta.hiddenByGroup;
+                            }
+                            else {
+                                meta.outlineLevel = next;
+                            }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (spans_1_1 && !spans_1_1.done && (_a = spans_1.return)) _a.call(spans_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "ungroup-rows", sheetId: sheetId, rowIndexes: rowIndexes });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

package/dist/cjs/hooks/use-on-update-named-range.d.ts

@@ -0,0 +1,19 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CellData, NamedRange } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { useCalculation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnUpdateNamedRangeProps<T extends CellData> = {
+    locale?: string;
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    getActiveCell(): CellInterface;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    onChangeNamedRanges: UseSpreadsheetProps<T>["onChangeNamedRanges"];
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnUpdateNamedRange: <T extends CellData>({ locale, getDependents, enqueueCalculation, createHistory, onChangeNamedRanges, onChangeSheetData, onCommand, }: UseOnUpdateNamedRangeProps<T>) => (sheetId: number, namedRange: NamedRange, previousNamedRange: NamedRange) => void;
+export {};
+//# sourceMappingURL=use-on-update-named-range.d.ts.map

package/dist/cjs/hooks/use-on-update-named-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-update-named-range.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-update-named-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAMtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,aAAa,IAAI,aAAa,CAAC;IAC/B,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACnE,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,kHAQvD,0BAA0B,CAAC,CAAC,CAAC,eAGlB,MAAM,cAAc,UAAU,sBAAsB,UAAU,SA+I3E,CAAC"}

package/dist/cjs/hooks/use-on-update-named-range.js

@@ -0,0 +1,133 @@
+import { __read, __values } from "tslib";
+import { isStaticNode } from "@rowsncolumns/dag";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export var useOnUpdateNamedRange = function (_a) {
+    var locale = _a.locale, getDependents = _a.getDependents, enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onChangeNamedRanges = _a.onChangeNamedRanges, onChangeSheetData = _a.onChangeSheetData, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, namedRange, previousNamedRange) {
+        // Protection — block named-range edits when the sheet is
+        // protected. Sheet-scoped names are clearly owned by `sheetId`;
+        // workbook-scoped names are typically authored from a sheet
+        // context so we use the same gate.
+        if (!canEditSheet(sheetId)) {
+            console.debug("Cannot update named range — sheet is protected.");
+            return;
+        }
+        var saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Create a cell
+        var sheetCell = new SheetCell();
+        // Update named range
+        onChangeNamedRanges === null || onChangeNamedRanges === void 0 ? void 0 : onChangeNamedRanges(function (prevNamedRanges) {
+            var _a = __read(produceWithPatches(prevNamedRanges, function (draft) {
+                var e_1, _a;
+                // Get the current range
+                var currentNamedRange = draft.find(function (n) { return n.namedRangeId === namedRange.namedRangeId; });
+                if (currentNamedRange) {
+                    // trigger recalc
+                    // Update dependent
+                    if (previousNamedRange.range) {
+                        try {
+                            for (var _b = __values(getDependents(previousNamedRange.range)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                var dependent = _c.value;
+                                if (isStaticNode(dependent)) {
+                                    continue;
+                                }
+                                var position = dependent.position;
+                                // Enqueu
+                                enqueueCalculation({
+                                    position: position,
+                                    type: "add",
+                                });
+                                // For undo/redo actions
+                                recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                            }
+                        }
+                        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; }
+                        }
+                    }
+                    // Update attributes
+                    currentNamedRange.name = namedRange.name;
+                    currentNamedRange.range = namedRange.range;
+                    currentNamedRange.value = namedRange.value;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Add to recalc cells
+            saveHistory({
+                namedRanges: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Update formulas that reference this named range
+        if (previousNamedRange.name !== namedRange.name) {
+            // Update all formula references
+            onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                    var e_2, _a;
+                    var _b;
+                    // Update dependent
+                    if (namedRange.range) {
+                        try {
+                            for (var _c = __values(getDependents(namedRange.range)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                var dependent = _d.value;
+                                if (isStaticNode(dependent)) {
+                                    continue;
+                                }
+                                var position = dependent.position;
+                                var rowIndex = position.rowIndex, columnIndex = position.columnIndex, sheetId_1 = position.sheetId;
+                                var currentSheet = createSheetDraft(draft, sheetId_1, rowIndex);
+                                var cellData = (_b = currentSheet[rowIndex].values) === null || _b === void 0 ? void 0 : _b[columnIndex];
+                                // Create a cell
+                                sheetCell.assign(sheetId_1, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, { locale: locale });
+                                // Update named range name
+                                sheetCell.changeNamedRangeName(namedRange.name, previousNamedRange.name);
+                                // Set cell data
+                                currentSheet[rowIndex].values[columnIndex] =
+                                    sheetCell.getCellData();
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                // Save sheet data
+                saveHistory({
+                    sheetData: { patches: patches, inversePatches: inversePatches },
+                });
+                return nextState;
+            });
+        }
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "update-named-range",
+            sheetId: sheetId,
+            namedRange: namedRange,
+            previousNamedRange: previousNamedRange,
+        });
+    }, [
+        locale,
+        onChangeNamedRanges,
+        onChangeSheetData,
+        enqueueCalculation,
+        createHistory,
+        getDependents,
+        onCommand,
+        canEditSheet,
+    ]);
+};

package/dist/cjs/hooks/use-on-update-note.d.ts

@@ -0,0 +1,13 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import { type CellData } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnUpdateNoteProps<T extends CellData> = {
+    locale: string;
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnUpdateNote: <T extends CellData>({ locale, createHistory, onChangeSheetData, onCommand, }: UseOnUpdateNoteProps<T>) => (sheetId: number, activeCell: CellInterface, note?: string) => void;
+//# sourceMappingURL=use-on-update-note.d.ts.map

package/dist/cjs/hooks/use-on-update-note.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-update-note.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-update-note.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAG1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,QAAQ,IAAI;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,QAAQ,EAAE,0DAKjD,oBAAoB,CAAC,CAAC,CAAC,eAGZ,MAAM,cAAc,aAAa,SAAS,MAAM,SAwB7D,CAAC"}

package/dist/cjs/hooks/use-on-update-note.js

@@ -0,0 +1,21 @@
+import { useCallback } from "react";
+import { insertNote } from "../interface/insert-note";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export var useOnUpdateNote = function (_a) {
+    var locale = _a.locale, createHistory = _a.createHistory, onChangeSheetData = _a.onChangeSheetData, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, activeCell, note) {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        // Insert note
+        insertNote({ locale: locale, createHistory: createHistory, onChangeSheetData: onChangeSheetData })(sheetId, activeCell, note);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "update-note",
+            sheetId: sheetId,
+            activeCell: activeCell,
+            note: note,
+        });
+    }, [locale, createHistory, onChangeSheetData, canEditSheet, onCommand]);
+};

package/dist/cjs/hooks/use-on-update-sheet.d.ts

@@ -0,0 +1,10 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnUpdateSheetProps<T extends CellData, S extends Sheet> = {
+    sheets?: S[];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+};
+export declare const useOnUpdateSheet: <T extends CellData, S extends Sheet = Sheet>({ sheets, onChangeSheets, createHistory, }: UseOnUpdateSheetProps<T, S>) => (sheetId: number, sheetSpec: Partial<S>) => S | undefined;
+//# sourceMappingURL=use-on-update-sheet.d.ts.map

package/dist/cjs/hooks/use-on-update-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-update-sheet.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-update-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAIjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACvE,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;IACb,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACtD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,GAAG,KAAK,EAAE,4CAI3E,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,eAEhB,MAAM,aAAa,OAAO,CAAC,CAAC,CAAC,kBAS1C,CAAC"}

package/dist/cjs/hooks/use-on-update-sheet.js

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { updateSheet } from "../interface/update-sheet";
+export var useOnUpdateSheet = function (_a) {
+    var sheets = _a.sheets, onChangeSheets = _a.onChangeSheets, createHistory = _a.createHistory;
+    return useCallback(function (sheetId, sheetSpec) {
+        return updateSheet({
+            sheets: sheets,
+            onChangeSheets: onChangeSheets,
+            createHistory: createHistory,
+        })(sheetId, sheetSpec);
+    }, [sheets, onChangeSheets, createHistory]);
+};

package/dist/cjs/hooks/use-paint-format.d.ts

@@ -0,0 +1,17 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { SelectionAttributes, SheetRange } from "@rowsncolumns/spreadsheet";
+import type { useOnChangeFormatting } from "./use-on-change-formatting";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { useSheetState } from "./use-sheet-state";
+export type UsePaintFormatProps = {
+    onChangeSelections: ReturnType<typeof useSheetState>["onChangeSelections"];
+    onChangeFormatting: ReturnType<typeof useOnChangeFormatting>["onChangeFormatting"];
+    getEffectiveFormat: ReturnType<typeof useSheetProperties>["getEffectiveFormat"];
+};
+export declare const usePaintFormat: ({ getEffectiveFormat, onChangeFormatting, onChangeSelections, }: UsePaintFormatProps) => {
+    isPaintFormatActive: boolean;
+    onSavePaintFormat: (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+    onApplyPaintFormat: (sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[]) => void;
+    paintFormat: (sourceSheetRange: SheetRange, targetSheetRange: SheetRange) => void;
+};
+//# sourceMappingURL=use-paint-format.d.ts.map

package/dist/cjs/hooks/use-paint-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-paint-format.d.ts","sourceRoot":"","sources":["../../../hooks/use-paint-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,OAAO,KAAK,EAEV,mBAAmB,EACnB,UAAU,EACX,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,MAAM,MAAM,mBAAmB,GAAG;IAChC,kBAAkB,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC3E,kBAAkB,EAAE,UAAU,CAC5B,OAAO,qBAAqB,CAC7B,CAAC,oBAAoB,CAAC,CAAC;IACxB,kBAAkB,EAAE,UAAU,CAC5B,OAAO,kBAAkB,CAC1B,CAAC,oBAAoB,CAAC,CAAC;CACzB,CAAC;AAMF,eAAO,MAAM,cAAc,GAAI,iEAI5B,mBAAmB;;iCAOP,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE;kCAiCvC,MAAM,cACH,aAAa,eACZ,aAAa,CAAC,mBAAmB,CAAC,EAAE;oCAsE/B,UAAU,oBAIV,UAAU;CAgDjC,CAAC"}

package/dist/cjs/hooks/use-paint-format.js

@@ -0,0 +1,118 @@
+import { __assign, __read, __values } from "tslib";
+import { selectionFromActiveCell } from "@rowsncolumns/grid";
+import { useCallback, useState } from "react";
+// A paint-format target spanning at least this many rows/cols is a header-click
+// full-column/row selection, not an intentional drag — bound it to the pattern.
+var UNBOUNDED_PAINT_SPAN = 10000;
+export var usePaintFormat = function (_a) {
+    var getEffectiveFormat = _a.getEffectiveFormat, onChangeFormatting = _a.onChangeFormatting, onChangeSelections = _a.onChangeSelections;
+    var _b = __read(useState([]), 2), paintFormats = _b[0], setPaintFormats = _b[1];
+    var onSavePaintFormat = useCallback(function (sheetId, activeCell, selections) {
+        var e_1, _a;
+        var finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        var paintFormats = [];
+        try {
+            for (var finalSelections_1 = __values(finalSelections), finalSelections_1_1 = finalSelections_1.next(); !finalSelections_1_1.done; finalSelections_1_1 = finalSelections_1.next()) {
+                var sel = finalSelections_1_1.value;
+                for (var rowIndex = sel.range.startRowIndex; rowIndex <= sel.range.endRowIndex; rowIndex++) {
+                    var rowFormats = [];
+                    for (var columnIndex = sel.range.startColumnIndex; columnIndex <= sel.range.endColumnIndex; columnIndex++) {
+                        rowFormats.push(getEffectiveFormat(sheetId, rowIndex, columnIndex));
+                    }
+                    paintFormats.push(rowFormats);
+                }
+            }
+        }
+        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; }
+        }
+        setPaintFormats(paintFormats);
+    }, [getEffectiveFormat]);
+    // Applies a saved paintFormat
+    var onApplyPaintFormat = useCallback(function (sheetId, activeCell, selections) {
+        /**
+         * Apply formatting
+         */
+        var rowSpan = paintFormats.length - 1;
+        var colSpan = paintFormats[0].length - 1;
+        // The pattern tiles across the full dragged target (Excel painter semantics —
+        // `changeFormatting` repeats the grid via its rolling indices). Only
+        // header-click full-column/row targets are bounded to the pattern so a paint
+        // never enumerates an entire 1M-row column.
+        var clampEnd = function (start, end, span) {
+            return end - start >= UNBOUNDED_PAINT_SPAN
+                ? Math.min(end, start + span)
+                : end;
+        };
+        var newSelections = (selections === null || selections === void 0 ? void 0 : selections.length)
+            ? selections.map(function (sel) { return (__assign(__assign({}, sel), { range: __assign(__assign({}, sel.range), { endRowIndex: clampEnd(sel.range.startRowIndex, sel.range.endRowIndex, rowSpan), endColumnIndex: clampEnd(sel.range.startColumnIndex, sel.range.endColumnIndex, colSpan) }) })); })
+            : [
+                {
+                    range: {
+                        startRowIndex: activeCell.rowIndex,
+                        endRowIndex: activeCell.rowIndex + rowSpan,
+                        startColumnIndex: activeCell.columnIndex,
+                        endColumnIndex: activeCell.columnIndex + colSpan,
+                    },
+                },
+            ];
+        // Apply
+        onChangeFormatting(sheetId, activeCell, newSelections, paintFormats, {
+            replace: true,
+        });
+        /**
+         * User has made selections. lets preserve it
+         */
+        if (!(selections === null || selections === void 0 ? void 0 : selections.length) && hasMultipleRowsAndCols(paintFormats)) {
+            onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(sheetId, newSelections);
+        }
+        // Reset paintformats
+        setPaintFormats([]);
+    }, [paintFormats, onChangeSelections, onChangeFormatting]);
+    /**
+     * Copy formatting from a source range to target range
+     */
+    var paintFormat = useCallback(function (
+    /**
+     * Sheet range to copy from
+     */
+    sourceSheetRange, 
+    /**
+     * Sheet range to paste to
+     */
+    targetSheetRange) {
+        var paintFormats = [];
+        for (var rowIndex = sourceSheetRange.startRowIndex; rowIndex <= sourceSheetRange.endRowIndex; rowIndex++) {
+            var rowFormats = [];
+            for (var columnIndex = sourceSheetRange.startColumnIndex; columnIndex <= sourceSheetRange.endColumnIndex; columnIndex++) {
+                rowFormats.push(getEffectiveFormat(sourceSheetRange.sheetId, rowIndex, columnIndex));
+            }
+            paintFormats.push(rowFormats);
+        }
+        // Apply
+        var activeCell = {
+            rowIndex: targetSheetRange.startRowIndex,
+            columnIndex: targetSheetRange.startColumnIndex,
+        };
+        // Copy formatting
+        onChangeFormatting(targetSheetRange.sheetId, activeCell, [{ range: targetSheetRange }], paintFormats, {
+            replace: true,
+        });
+    }, [onChangeFormatting, getEffectiveFormat]);
+    return {
+        isPaintFormatActive: paintFormats.length > 0,
+        onSavePaintFormat: onSavePaintFormat,
+        onApplyPaintFormat: onApplyPaintFormat,
+        paintFormat: paintFormat,
+    };
+};
+// Check if there are multiple row and cols
+var hasMultipleRowsAndCols = function (arr) {
+    return arr && arr.length > 1 && arr[0] && arr[0].length > 1;
+};

package/dist/cjs/hooks/use-search.d.ts

@@ -0,0 +1,81 @@
+import type { CellData, RangeBorderStyle, Sheet, SheetCoordinate } from "@rowsncolumns/spreadsheet";
+export type UseSearchProps<T extends CellData, S extends Sheet> = {
+    getNonEmptyRowCount(sheetId: number): number | undefined;
+    getNonEmptyColumnCount(sheetId: number, rowIndex: number): number | undefined;
+    /**
+     * Active sheet id
+     */
+    sheetId: number;
+    /**
+     * Use to switch sheet during a search
+     * @param sheetId
+     */
+    onChangeActiveSheet?(sheetId: number): void;
+    getCellData(sheetId: number, rowIndex: number, columnIndex: number): T | undefined | null;
+    getFormattedValue?(sheetId: number, rowIndex: number, columnIndex: number): string | undefined | null;
+    matchPredicate?<T extends CellData>(cellData: T | null | undefined, query: string, options?: SearchOptions): boolean;
+    /**
+     * Off-window match provider. When supplied, `onSearch` delegates the actual scan to this instead of
+     * iterating cells via the accessors — required for a WINDOWED engine where the JS side only holds
+     * the loaded viewport, so matches outside it are invisible to the accessor walk. The engine hook
+     * passes `(query, options) => engine.findAll(activeSheetId, query, options)`, which scans the whole
+     * document in Rust and returns coordinates row-major. Everything else (highlighting, next/prev,
+     * counter, scroll-to-result) is unchanged. Omit it for the in-memory (Option-A) path.
+     */
+    findMatches?(query: string, options?: SearchOptions): SheetCoordinate[];
+} & ({
+    searchAllSheets: true;
+    sheets: S[];
+} | {
+    searchAllSheets?: false;
+    sheets?: S[];
+});
+/**
+ * Per-search toggles wired up by the search UI. `matchCase` and
+ * `wholeWord` mirror Excel / Sheets behaviour. `useRegex` skips
+ * escape-then-substring and feeds the raw query straight into
+ * `RegExp` — invalid patterns return zero matches rather than
+ * throw, matching VS Code's UX. When all are omitted the search is
+ * case-insensitive substring matching.
+ */
+export type SearchOptions = {
+    matchCase?: boolean;
+    wholeWord?: boolean;
+    useRegex?: boolean;
+};
+/**
+ * Build the regex used to match cell content. `\b` works for ASCII
+ * word boundaries; that's the same compromise Excel and Sheets ship.
+ * Returns `undefined` when `useRegex` is on and the user-supplied
+ * pattern fails to compile — callers treat that as zero matches.
+ */
+export declare const buildSearchRegex: (query: string, options?: SearchOptions) => RegExp | undefined;
+/**
+ * Raw (effective) cell value as a string, so a search for `3000`
+ * also matches a cell displayed as `3,000`. Numbers use their
+ * canonical `String()` form; booleans mirror the grid's TRUE/FALSE.
+ */
+export declare const getCellEffectiveValueString: <T extends CellData>(cellData: T | null | undefined) => string | undefined;
+export declare const defaultMatchPredicate: <T extends CellData>(cellData: T | null | undefined, query: string, options?: SearchOptions) => boolean;
+/**
+ * Use search hook
+ * @param param0
+ * @returns
+ */
+export declare const useSearch: <T extends CellData, S extends Sheet>({ sheetId, sheets, searchAllSheets, onChangeActiveSheet, getNonEmptyRowCount, getNonEmptyColumnCount, getCellData, getFormattedValue, matchPredicate, findMatches, }: UseSearchProps<T, S>) => {
+    onSearch: (query: string, options?: SearchOptions, scrollToActiveCell?: boolean) => void;
+    onResetSearch: () => void;
+    borderStyles: RangeBorderStyle[];
+    onFocusNextResult: () => void;
+    onFocusPreviousResult: () => void;
+    hasPreviousResult: boolean;
+    hasNextResult: boolean;
+    searchQuery: string | undefined;
+    onRequestSearch: () => void;
+    isSearchActive: boolean;
+    currentResult: number;
+    totalResults: number;
+    activeResult: SheetCoordinate;
+    searchOptions: SearchOptions | undefined;
+};
+//# sourceMappingURL=use-search.d.ts.map

package/dist/cjs/hooks/use-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-search.d.ts","sourceRoot":"","sources":["../../../hooks/use-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,gBAAgB,EAChB,KAAK,EACL,eAAe,EAChB,MAAM,2BAA2B,CAAC;AAenC,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAChE,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACzD,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC9E;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,mBAAmB,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,WAAW,CACT,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;IACxB,iBAAiB,CAAC,CAChB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IAC7B,cAAc,CAAC,CAAC,CAAC,SAAS,QAAQ,EAChC,QAAQ,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC;IACX;;;;;;;OAOG;IACH,WAAW,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,eAAe,EAAE,CAAC;CACzE,GAAG,CACA;IAAE,eAAe,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,CAAC,EAAE,CAAA;CAAE,GACtC;IAAE,eAAe,CAAC,EAAE,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAA;CAAE,CAC5C,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,EACb,UAAU,aAAa,KACtB,MAAM,GAAG,SAYX,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GAAI,CAAC,SAAS,QAAQ,EAC5D,UAAU,CAAC,GAAG,IAAI,GAAG,SAAS,KAC7B,MAAM,GAAG,SAkBX,CAAC;AAgBF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EACtD,UAAU,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9B,OAAO,MAAM,EACb,UAAU,aAAa,YAUxB,CAAC;AAIF;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sKAW5D,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC;sBAoCT,MAAM,YAAY,aAAa;;;;;;;;;;;;;;CA0L5C,CAAC"}