@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/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/esm/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/esm/hooks/use-on-ungroup-rows.js

@@ -0,0 +1,49 @@
+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 const useOnUngroupRows = ({ createHistory, onChangeSheets, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    return useCallback((sheetId, rowIndexes) => {
+        if (!canEditSheet(sheetId) || rowIndexes.length === 0)
+            return;
+        const saveHistory = createHistory();
+        const sorted = [...rowIndexes].sort((a, b) => a - b);
+        const spans = contiguousSpans(sorted);
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((s) => s.sheetId === sheetId);
+                if (!sheet?.rowMetadata)
+                    return;
+                for (const { start, end } of spans) {
+                    for (let r = start; r <= end; r++) {
+                        const meta = sheet.rowMetadata[r];
+                        if (!meta)
+                            continue;
+                        const current = meta.outlineLevel ?? 0;
+                        if (current <= 0)
+                            continue;
+                        const next = current - 1;
+                        if (next === 0) {
+                            delete meta.outlineLevel;
+                            delete meta.collapsed;
+                            delete meta.hiddenByGroup;
+                        }
+                        else {
+                            meta.outlineLevel = next;
+                        }
+                    }
+                }
+            });
+            saveHistory({ sheets: { patches, inversePatches } });
+            return nextState;
+        });
+        onCommand?.({ command: "ungroup-rows", sheetId, rowIndexes });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

package/dist/esm/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/esm/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/esm/hooks/use-on-update-named-range.js

@@ -0,0 +1,108 @@
+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 const useOnUpdateNamedRange = ({ locale, getDependents, enqueueCalculation, createHistory, onChangeNamedRanges, onChangeSheetData, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    return useCallback((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;
+        }
+        const saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // Create a cell
+        const sheetCell = new SheetCell();
+        // Update named range
+        onChangeNamedRanges?.((prevNamedRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevNamedRanges, (draft) => {
+                // Get the current range
+                const currentNamedRange = draft.find((n) => n.namedRangeId === namedRange.namedRangeId);
+                if (currentNamedRange) {
+                    // trigger recalc
+                    // Update dependent
+                    if (previousNamedRange.range) {
+                        for (const dependent of getDependents(previousNamedRange.range)) {
+                            if (isStaticNode(dependent)) {
+                                continue;
+                            }
+                            const { position } = dependent;
+                            // Enqueu
+                            enqueueCalculation({
+                                position,
+                                type: "add",
+                            });
+                            // For undo/redo actions
+                            recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                        }
+                    }
+                    // Update attributes
+                    currentNamedRange.name = namedRange.name;
+                    currentNamedRange.range = namedRange.range;
+                    currentNamedRange.value = namedRange.value;
+                }
+            });
+            // Add to recalc cells
+            saveHistory({
+                namedRanges: { patches, 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?.((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                    // Update dependent
+                    if (namedRange.range) {
+                        for (const dependent of getDependents(namedRange.range)) {
+                            if (isStaticNode(dependent)) {
+                                continue;
+                            }
+                            const { position } = dependent;
+                            const { rowIndex, columnIndex, sheetId } = position;
+                            const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                            const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                            // Create a cell
+                            sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, { locale });
+                            // Update named range name
+                            sheetCell.changeNamedRangeName(namedRange.name, previousNamedRange.name);
+                            // Set cell data
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                        }
+                    }
+                });
+                // Save sheet data
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                });
+                return nextState;
+            });
+        }
+        onCommand?.({
+            command: "update-named-range",
+            sheetId,
+            namedRange,
+            previousNamedRange,
+        });
+    }, [
+        locale,
+        onChangeNamedRanges,
+        onChangeSheetData,
+        enqueueCalculation,
+        createHistory,
+        getDependents,
+        onCommand,
+        canEditSheet,
+    ]);
+};

package/dist/esm/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/esm/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/esm/hooks/use-on-update-note.js

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

package/dist/esm/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/esm/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/esm/hooks/use-on-update-sheet.js

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

package/dist/esm/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/esm/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/esm/hooks/use-paint-format.js

@@ -0,0 +1,110 @@
+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.
+const UNBOUNDED_PAINT_SPAN = 10_000;
+export const usePaintFormat = ({ getEffectiveFormat, onChangeFormatting, onChangeSelections, }) => {
+    const [paintFormats, setPaintFormats] = useState([]);
+    const onSavePaintFormat = useCallback((sheetId, activeCell, selections) => {
+        const finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        const paintFormats = [];
+        for (const sel of finalSelections) {
+            for (let rowIndex = sel.range.startRowIndex; rowIndex <= sel.range.endRowIndex; rowIndex++) {
+                const rowFormats = [];
+                for (let columnIndex = sel.range.startColumnIndex; columnIndex <= sel.range.endColumnIndex; columnIndex++) {
+                    rowFormats.push(getEffectiveFormat(sheetId, rowIndex, columnIndex));
+                }
+                paintFormats.push(rowFormats);
+            }
+        }
+        setPaintFormats(paintFormats);
+    }, [getEffectiveFormat]);
+    // Applies a saved paintFormat
+    const onApplyPaintFormat = useCallback((sheetId, activeCell, selections) => {
+        /**
+         * Apply formatting
+         */
+        const rowSpan = paintFormats.length - 1;
+        const 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.
+        const clampEnd = (start, end, span) => end - start >= UNBOUNDED_PAINT_SPAN
+            ? Math.min(end, start + span)
+            : end;
+        const newSelections = selections?.length
+            ? selections.map((sel) => ({
+                ...sel,
+                range: {
+                    ...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?.length && hasMultipleRowsAndCols(paintFormats)) {
+            onChangeSelections?.(sheetId, newSelections);
+        }
+        // Reset paintformats
+        setPaintFormats([]);
+    }, [paintFormats, onChangeSelections, onChangeFormatting]);
+    /**
+     * Copy formatting from a source range to target range
+     */
+    const paintFormat = useCallback((
+    /**
+     * Sheet range to copy from
+     */
+    sourceSheetRange, 
+    /**
+     * Sheet range to paste to
+     */
+    targetSheetRange) => {
+        const paintFormats = [];
+        for (let rowIndex = sourceSheetRange.startRowIndex; rowIndex <= sourceSheetRange.endRowIndex; rowIndex++) {
+            const rowFormats = [];
+            for (let columnIndex = sourceSheetRange.startColumnIndex; columnIndex <= sourceSheetRange.endColumnIndex; columnIndex++) {
+                rowFormats.push(getEffectiveFormat(sourceSheetRange.sheetId, rowIndex, columnIndex));
+            }
+            paintFormats.push(rowFormats);
+        }
+        // Apply
+        const 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,
+        onApplyPaintFormat,
+        paintFormat,
+    };
+};
+// Check if there are multiple row and cols
+const hasMultipleRowsAndCols = (arr) => {
+    return arr && arr.length > 1 && arr[0] && arr[0].length > 1;
+};

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