@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/use-on-request-insert-image.d.ts

@@ -0,0 +1,3 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+export declare const useOnRequestInsertImage: () => (sheetId: number, activeCell: CellInterface, insertOverCells?: boolean) => void;
+//# sourceMappingURL=use-on-request-insert-image.d.ts.map

package/dist/esm/hooks/use-on-request-insert-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-insert-image.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-insert-image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAMhE,eAAO,MAAM,uBAAuB,kBAItB,MAAM,cAAc,aAAa,oBAAoB,OAAO,SAOzE,CAAC"}

package/dist/esm/hooks/use-on-request-insert-image.js

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { useSetInsertImageDialogState } from "../atoms/dialog-state.atom";
+import { useSetInsertImageOverCellsState } from "../atoms/insert-image-state.atom";
+export const useOnRequestInsertImage = () => {
+    const setInsertImageDialog = useSetInsertImageDialogState();
+    const setInsertImageOverCellsState = useSetInsertImageOverCellsState();
+    return useCallback((sheetId, activeCell, insertOverCells) => {
+        setInsertImageOverCellsState(insertOverCells);
+        // Open resize dialog
+        setInsertImageDialog(true);
+    }, [setInsertImageDialog, setInsertImageOverCellsState]);
+};

package/dist/esm/hooks/use-on-request-insert-link.d.ts

@@ -0,0 +1,5 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { SelectionArea } from "@rowsncolumns/common-types";
+import type { SelectionAttributes } from "@rowsncolumns/spreadsheet";
+export declare const useOnRequestInsertLink: () => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+//# sourceMappingURL=use-on-request-insert-link.d.ts.map

package/dist/esm/hooks/use-on-request-insert-link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-insert-link.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-insert-link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAKrE,eAAO,MAAM,sBAAsB,kBAIpB,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAOrD,CAAC"}

package/dist/esm/hooks/use-on-request-insert-link.js

@@ -0,0 +1,9 @@
+import { useCallback } from "react";
+import { useSetInsertLinkDialogState } from "../atoms/dialog-state.atom";
+export const useOnRequestInsertLink = () => {
+    const setInsertLinkDialog = useSetInsertLinkDialogState();
+    return useCallback((sheetId, activeCell, selections) => {
+        // Open resize dialog
+        setInsertLinkDialog(true);
+    }, [setInsertLinkDialog]);
+};

package/dist/esm/hooks/use-on-request-resize.d.ts

@@ -0,0 +1,3 @@
+import type { AXIS } from "@rowsncolumns/spreadsheet";
+export declare const useOnRequestResize: () => (sheetId: number, indexes: number[], axis: AXIS) => void;
+//# sourceMappingURL=use-on-request-resize.d.ts.map

package/dist/esm/hooks/use-on-request-resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-resize.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-resize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAC,MAAM,2BAA2B,CAAC;AAMrD,eAAO,MAAM,kBAAkB,kBAIjB,MAAM,WAAW,MAAM,EAAE,QAAQ,IAAI,SASlD,CAAC"}

package/dist/esm/hooks/use-on-request-resize.js

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useSetResizeDimensionDialogState } from "../atoms/dialog-state.atom";
+import { useSetResizeDimension } from "../atoms/resize-dimension.atom";
+export const useOnRequestResize = () => {
+    const setOpenResizeDialog = useSetResizeDimensionDialogState();
+    const setResizeDimension = useSetResizeDimension();
+    return useCallback((sheetId, indexes, axis) => {
+        // Open resize dialog
+        setOpenResizeDialog(true);
+        // set values in state
+        setResizeDimension({ sheetId, indexes, axis });
+    }, [setOpenResizeDialog, setResizeDimension]);
+};

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

@@ -0,0 +1,3 @@
+import type { NamedRange } from "@rowsncolumns/spreadsheet";
+export declare const useOnRequestUpdateNamedRange: () => (sheetId: number, namedRange: NamedRange) => void;
+//# sourceMappingURL=use-on-request-update-named-range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-update-named-range.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-update-named-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAM5D,eAAO,MAAM,4BAA4B,kBAI3B,MAAM,cAAc,UAAU,SAO3C,CAAC"}

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

@@ -0,0 +1,11 @@
+import { useCallback } from "react";
+import { useSetEditNamedRangeDialogState } from "../atoms/dialog-state.atom";
+import { useSetEditingNamedRange } from "../atoms/named-range.atom";
+export const useOnRequestUpdateNamedRange = () => {
+    const setEditDialog = useSetEditNamedRangeDialogState();
+    const setEditingNamedRange = useSetEditingNamedRange();
+    return useCallback((sheetId, namedRange) => {
+        setEditingNamedRange(namedRange);
+        setEditDialog(true);
+    }, [setEditDialog, setEditingNamedRange]);
+};

package/dist/esm/hooks/use-on-resize-table.d.ts

@@ -0,0 +1,33 @@
+import type { CellInterface } from "@rowsncolumns/grid";
+import { type GridRange } from "@rowsncolumns/grid";
+import { type CellData, type FilterView, type Sheet, type TableView } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { GeneratedNames } from "../generated-names";
+import type { useCalculation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnResizeTableProps<T extends CellData, S extends Sheet> = {
+    rowCount: number;
+    columnCount: number;
+    locale: string;
+    tables?: TableView[];
+    basicFilter?: FilterView | null;
+    getActiveCell(): CellInterface;
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueGraphOperation: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    getFormattedValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined | null;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    onCommand?: OnCommand;
+    generatedNames?: GeneratedNames;
+};
+/**
+ * Sorts a column
+ * @param param0
+ * @returns
+ */
+export declare const useOnResizeTable: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, basicFilter, tables, getActiveCell, createHistory, enqueueCalculation, enqueueGraphOperation, onChangeTables, onChangeSheetData, getFormattedValue, getDependents, onCommand, generatedNames, }: UseOnResizeTableProps<T, S>) => (sheetId: number, table: TableView, range: GridRange) => void;
+export {};
+//# sourceMappingURL=use-on-resize-table.d.ts.map

package/dist/esm/hooks/use-on-resize-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-resize-table.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-resize-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,SAAS,EAEf,MAAM,2BAA2B,CAAC;AASnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAQzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,qBAAqB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,aAAa,IAAI,aAAa,CAAC;IAC/B,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,qBAAqB,EAAE,UAAU,CAC/B,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,iBAAiB,EAAE,CACjB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IAC/B,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kOAgBnE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,eAIhB,MAAM,SAAS,SAAS,SAAS,SAAS,SAqRvD,CAAC"}

package/dist/esm/hooks/use-on-resize-table.js

@@ -0,0 +1,212 @@
+import { areaIntersects } from "@rowsncolumns/grid";
+import { useTokenizer, } from "@rowsncolumns/spreadsheet";
+import { combineIterators, iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { processSideEffectDependentCells } from "../api/dependency";
+import { createSheetDraft } from "../api/immer-utils";
+import { addTableNameToTokens } from "../api/table";
+import { useShowError } from "../atoms";
+import { getNextTableColumnName } from "../helpers";
+import { addCalculatedColumnsForRowExpansion, processTableDependentCells, } from "../interface/change-table-column";
+import { SheetCell } from "../sheet-cell";
+import { addTableColumn } from "./use-on-table";
+/**
+ * Sorts a column
+ * @param param0
+ * @returns
+ */
+export const useOnResizeTable = ({ rowCount, columnCount, locale, basicFilter, tables, getActiveCell, createHistory, enqueueCalculation, enqueueGraphOperation, onChangeTables, onChangeSheetData, getFormattedValue, getDependents, onCommand, generatedNames, }) => {
+    const showError = useShowError();
+    const tokenizer = useTokenizer();
+    return useCallback((sheetId, table, range) => {
+        // Validate
+        const basicFilterIntersects = areaIntersects(range, basicFilter?.range);
+        if (basicFilterIntersects) {
+            showError({
+                title: "Error",
+                message: "This operation is attempting to change a filtered range on your worksheet and cannot be completed.",
+            });
+            return;
+        }
+        const tableIntersects = tables?.some((cur) => cur.sheetId == sheetId &&
+            cur.id !== table.id &&
+            areaIntersects(cur.range, range));
+        // Check if other tables intersects
+        if (tableIntersects) {
+            showError({
+                title: "Error",
+                message: "This operation cannot be completed as it spans the cells over multiple tables.",
+            });
+            return;
+        }
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // History
+        const saveHistory = createHistory();
+        /**
+         * 1. Set modified cells and dirty
+         * 2. Expand calculated columns
+         */
+        const rowDelta = table.range.endRowIndex - range.endRowIndex;
+        const columnDelta = table.range.endColumnIndex - range.endColumnIndex;
+        const dirtyColumnRange = {
+            ...range,
+            startRowIndex: range.startRowIndex + (table.headerRow ? 1 : 0),
+            startColumnIndex: Math.min(table.range.endColumnIndex, range.endColumnIndex),
+            endColumnIndex: Math.max(table.range.endColumnIndex, range.endColumnIndex),
+        };
+        const dirtyRowRange = {
+            ...range,
+            startRowIndex: Math.min(table.range.endRowIndex + (table.headerRow ? 1 : 0), range.endRowIndex),
+            endRowIndex: Math.max(table.range.endRowIndex, range.endRowIndex),
+        };
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const movedKeys = new Set();
+                // Mark row range as dirty
+                for (const [rowIndex, columnIndex] of combineIterators(rowDelta === 0 ? undefined : iterateCellsInRange(dirtyRowRange), columnDelta === 0
+                    ? undefined
+                    : iterateCellsInRange(dirtyColumnRange))) {
+                    // Process dependents
+                    processSideEffectDependentCells({
+                        draft,
+                        rowIndex,
+                        columnIndex,
+                        sheetId,
+                        columnDelta: 0,
+                        enqueueGraphOperation,
+                        enqueueCalculation,
+                        getDependents,
+                        recalcCells,
+                        rowDelta: 0,
+                        sourceRange: dirtyRowRange,
+                        movedKeys,
+                        locale,
+                        rowCount,
+                        columnCount,
+                    });
+                }
+                // Add table column to cell
+                addTableColumn({
+                    draft,
+                    getFormattedValue,
+                    sheetId,
+                    range,
+                    locale,
+                    generatedNames,
+                });
+                // Add computed column
+                addCalculatedColumnsForRowExpansion({
+                    sheetId,
+                    currentTable: table,
+                    draft,
+                    enqueueCalculation,
+                    recalcCells,
+                    locale,
+                    range: dirtyColumnRange,
+                    getDependents,
+                });
+                // Update dependent cells
+                processTableDependentCells(table, getDependents, recalcCells, enqueueCalculation);
+                // If table column is removed
+                // update relative column references
+                // and add table name
+                // ie: update [@column] => Table[@column]
+                if (range.endColumnIndex < table.range.endColumnIndex) {
+                    const start = range.endColumnIndex + 1;
+                    const sheetCell = new SheetCell();
+                    for (let columnIndex = start; columnIndex <= table.range.endColumnIndex; columnIndex++) {
+                        const colIdx = columnIndex - table.range.startColumnIndex;
+                        const column = table.columns?.[colIdx];
+                        if (column?.formula) {
+                            // We have to update formulas
+                            for (let rowIndex = table.range.startRowIndex + (table.headerRow ? 1 : 0); rowIndex <= table.range.endRowIndex; rowIndex++) {
+                                const cellData = draft[sheetId]?.[rowIndex]?.values?.[columnIndex];
+                                // Add to cell
+                                sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, { locale });
+                                if (sheetCell.formula) {
+                                    const tokens = tokenizer(sheetCell.formula);
+                                    const newFormula = addTableNameToTokens(tokens, table.title);
+                                    // Set formula value
+                                    sheetCell.setFormulaValue(newFormula);
+                                    // Current sheet
+                                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                    // Update data
+                                    currentSheet[rowIndex].values[columnIndex] =
+                                        sheetCell.getCellData();
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+            });
+            return nextState;
+        });
+        // Update table sort specs
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                const currentTable = draft.find((cur) => cur.id === table.id);
+                if (currentTable) {
+                    // Columns
+                    const newColumnLength = range.endColumnIndex - range.startColumnIndex + 1;
+                    if (currentTable.headerRow) {
+                        if (!currentTable.columns) {
+                            currentTable.columns = [];
+                        }
+                        // Set length
+                        currentTable.columns = currentTable.columns.slice(0, newColumnLength);
+                        for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                            const formattedValue = getFormattedValue(sheetId, range.startRowIndex, columnIndex);
+                            const columnName = formattedValue ??
+                                getNextTableColumnName(currentTable.columns, generatedNames);
+                            const colIndex = columnIndex - range.startColumnIndex;
+                            if (!currentTable.columns[colIndex]) {
+                                currentTable.columns[colIndex] = {
+                                    name: columnName,
+                                };
+                            }
+                        }
+                    }
+                    // Update table range
+                    currentTable.range = range;
+                }
+            });
+            // Save history
+            saveHistory({
+                tables: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        onCommand?.({
+            command: "resize-table",
+            sheetId,
+            table,
+            range,
+        });
+    }, [
+        rowCount,
+        columnCount,
+        locale,
+        basicFilter,
+        tables,
+        getActiveCell,
+        tokenizer,
+        showError,
+        createHistory,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        onChangeTables,
+        onChangeSheetData,
+        getFormattedValue,
+        getDependents,
+        onCommand,
+        generatedNames,
+    ]);
+};

package/dist/esm/hooks/use-on-resize.d.ts

@@ -0,0 +1,19 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CanvasGridMethods } from "@rowsncolumns/spreadsheet";
+import { type AXIS, type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseOnChangeFormattingProps } from "./use-on-change-formatting";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnResizeProps<T extends CellData, S extends Sheet> = {
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    getActiveCell: () => CellInterface;
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    getCellDimensions: UseOnChangeFormattingProps<T, S>["getCellDimensions"];
+    getRowHeight: CanvasGridMethods["getRowHeight"];
+    isMergedCell: UseOnChangeFormattingProps<T, S>["isMergedCell"];
+    onCommand?: OnCommand;
+};
+export declare const useOnResize: <T extends CellData, S extends Sheet>({ onChangeSheets, createHistory, getActiveCell, getCellDimensions, getRowHeight, isMergedCell, onCommand, }: UseOnResizeProps<T, S>) => (sheetId: number, indexes: number[], dimension: number, axis: AXIS, autoFit?: boolean) => void;
+export { autoResizeRows } from "../interface/resize-utils";
+//# sourceMappingURL=use-on-resize.d.ts.map

package/dist/esm/hooks/use-on-resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-resize.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-resize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAGjF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQ7C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAClE,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,aAAa,EAAE,MAAM,aAAa,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,iBAAiB,EAAE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IACzE,YAAY,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC;IAChD,YAAY,EAAE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;IAC/D,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,6GAQ9D,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,eAMV,MAAM,WACN,MAAM,EAAE,aACN,MAAM,QACX,IAAI,YACA,OAAO,SA0DtB,CAAC;AACF,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/esm/hooks/use-on-resize.js

@@ -0,0 +1,54 @@
+import { useCallback } from "react";
+import { resize } from "../interface/resize";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditSheet, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export const useOnResize = ({ onChangeSheets, createHistory, getActiveCell, getCellDimensions, getRowHeight, isMergedCell, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    const canPerformSheetAction = useCanPerformSheetAction();
+    const showError = useShowError();
+    return useCallback((sheetId, indexes, dimension, axis, autoFit) => {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        // `axis === "x"` resizes rows (rowMetadata), `"y"` resizes columns.
+        if (!canPerformSheetAction(sheetId, axis === "x" ? "formatRows" : "formatColumns")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: axis === "x"
+                    ? "You can't resize rows on a protected sheet."
+                    : "You can't resize columns on a protected sheet.",
+            });
+            return;
+        }
+        const result = resize({
+            createHistory,
+            getActiveCell,
+            getCellDimensions,
+            getRowHeight,
+            isMergedCell,
+            onChangeSheets,
+        })(sheetId, indexes, dimension, axis, autoFit);
+        onCommand?.({
+            command: "resize",
+            sheetId,
+            indexes,
+            dimension,
+            axis,
+            autoFit,
+        });
+        return result;
+    }, [
+        onChangeSheets,
+        getActiveCell,
+        createHistory,
+        canEditSheet,
+        canPerformSheetAction,
+        showError,
+        getCellDimensions,
+        isMergedCell,
+        getRowHeight,
+        onCommand,
+    ]);
+};
+export { autoResizeRows } from "../interface/resize-utils";

package/dist/esm/hooks/use-on-set-outline-depth.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 UseOnSetOutlineDepthProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onCommand?: OnCommand;
+};
+/**
+ * `useOnSetOutlineDepth` returns a callback `(sheetId, axis, depth)`
+ * that mirrors Excel's outline level buttons. Wires the same
+ * collapse/expand semantics the per-group hooks use, but in one pass
+ * across the whole sheet.
+ */
+export declare const useOnSetOutlineDepth: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onCommand, }: UseOnSetOutlineDepthProps<T, S>) => (sheetId: number, axis: "row" | "column", depth: number) => void;
+//# sourceMappingURL=use-on-set-outline-depth.d.ts.map

package/dist/esm/hooks/use-on-set-outline-depth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-set-outline-depth.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-set-outline-depth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAER,KAAK,EACN,MAAM,2BAA2B,CAAC;AAKnC,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,yBAAyB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC3E,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;AA2EF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAIvE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,eAGpB,MAAM,QAAQ,KAAK,GAAG,QAAQ,SAAS,MAAM,SAyB1D,CAAC"}

package/dist/esm/hooks/use-on-set-outline-depth.js

@@ -0,0 +1,93 @@
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+/**
+ * Apply Excel's "outline level" buttons (1, 2, 3 in the gutter
+ * corner). `depth` = N means: groups at level >= N are COLLAPSED,
+ * groups at level < N are EXPANDED. So `depth=1` collapses every
+ * group; `depth=maxLevel + 1` expands every group.
+ *
+ * Walks `rowMetadata` (when `axis="row"`) or `columnMetadata` once,
+ * identifies every outline summary using the same level-transition
+ * scan the gutter uses, and toggles `hiddenByGroup` on each group's
+ * children + `collapsed` on the summary cell.
+ */
+const applyDepth = (sheet, axis, depth) => {
+    const metadataKey = axis === "row" ? "rowMetadata" : "columnMetadata";
+    const metadata = sheet[metadataKey];
+    if (!metadata?.length)
+        return;
+    const length = metadata.length;
+    // Pass 1: set `hiddenByGroup` from each cell's own `outlineLevel`.
+    // Using each cell's own level (rather than scanning groups and
+    // writing to ranges) is what makes nested groups behave correctly —
+    // a level-2 child stays hidden when its level-1 parent expands,
+    // because the two writes don't overlap.
+    for (let i = 0; i < length; i++) {
+        const meta = metadata[i];
+        const level = meta?.outlineLevel ?? 0;
+        if (level > 0 && level >= depth) {
+            if (!metadata[i]) {
+                metadata[i] = {};
+            }
+            metadata[i].hiddenByGroup = true;
+        }
+        else if (meta?.hiddenByGroup) {
+            delete metadata[i].hiddenByGroup;
+        }
+    }
+    // Pass 2: scan level transitions to set `collapsed` on summary cells.
+    // Same shape as `findSummaries`; duplicated here so the state layer
+    // doesn't depend on the render layer. The summary's collapsed state
+    // tracks the INNERMOST closing group (= `prevLevel`) — that matches
+    // both Excel's visual semantics and what the per-group +/- button
+    // operates on.
+    const levelAt = (i) => i >= 0 && i < length ? metadata[i]?.outlineLevel ?? 0 : 0;
+    let prevLevel = 0;
+    for (let i = 0; i <= length; i++) {
+        const curr = levelAt(i);
+        if (curr < prevLevel) {
+            const summaryIndex = i;
+            const shouldCollapse = prevLevel >= depth;
+            if (shouldCollapse) {
+                if (!metadata[summaryIndex]) {
+                    metadata[summaryIndex] = {};
+                }
+                metadata[summaryIndex].collapsed = true;
+            }
+            else if (metadata[summaryIndex]?.collapsed) {
+                delete metadata[summaryIndex].collapsed;
+            }
+        }
+        prevLevel = curr;
+    }
+};
+/**
+ * `useOnSetOutlineDepth` returns a callback `(sheetId, axis, depth)`
+ * that mirrors Excel's outline level buttons. Wires the same
+ * collapse/expand semantics the per-group hooks use, but in one pass
+ * across the whole sheet.
+ */
+export const useOnSetOutlineDepth = ({ createHistory, onChangeSheets, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    return useCallback((sheetId, axis, depth) => {
+        if (!canEditSheet(sheetId))
+            return;
+        const saveHistory = createHistory();
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((s) => s.sheetId === sheetId);
+                if (sheet)
+                    applyDepth(sheet, axis, depth);
+            });
+            saveHistory({ sheets: { patches, inversePatches } });
+            return nextState;
+        });
+        onCommand?.({
+            command: "set-outline-depth",
+            sheetId,
+            axis,
+            depth,
+        });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

package/dist/esm/hooks/use-on-show-column.d.ts

@@ -0,0 +1,16 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnShowColumnProps<T extends CellData, S extends Sheet> = {
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeActiveCell(sheetId: number, cell: CellInterface): void;
+    onChangeSelections(sheetId: number, selections: SelectionArea<SelectionAttributes>[]): void;
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    rowCount: number | undefined;
+    onCommand?: OnCommand;
+};
+export declare const useOnShowColumn: <T extends CellData, S extends Sheet>({ createHistory, onChangeActiveCell, onChangeSelections, onChangeSheets, rowCount, onCommand, }: UseOnShowColumnProps<T, S>) => (sheetId: number, columnIndexes: number[]) => void;
+export {};
+//# sourceMappingURL=use-on-show-column.d.ts.map

package/dist/esm/hooks/use-on-show-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-show-column.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-show-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,OAAO,KAAK,EACV,QAAQ,EAER,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAO7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC/D,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAAC;IAC/D,kBAAkB,CAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,GAC/C,IAAI,CAAC;IACR,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,iGAOlE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,eAMf,MAAM,iBAAiB,MAAM,EAAE,SAwF5C,CAAC"}

package/dist/esm/hooks/use-on-show-column.js

@@ -0,0 +1,82 @@
+import { Direction } from "@rowsncolumns/grid";
+import { DEFAULT_ROW_COUNT, useSpreadsheet } from "@rowsncolumns/spreadsheet";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditSheet, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export const useOnShowColumn = ({ createHistory, onChangeActiveCell, onChangeSelections, onChangeSheets, rowCount = DEFAULT_ROW_COUNT, onCommand, }) => {
+    const { getNextFocusableCell } = useSpreadsheet();
+    const canEditSheet = useCanEditSheet();
+    const canPerformSheetAction = useCanPerformSheetAction();
+    const showError = useShowError();
+    return useCallback((sheetId, columnIndexes) => {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        if (!canPerformSheetAction(sheetId, "formatColumns")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't hide or show columns on a protected sheet.",
+            });
+            return;
+        }
+        const saveHistory = createHistory();
+        const firstColumnIndex = columnIndexes[0];
+        const newActiveCell = getNextFocusableCell?.(sheetId, { rowIndex: 0, columnIndex: firstColumnIndex }, Direction.Down, false) ?? { rowIndex: 1, columnIndex: firstColumnIndex };
+        const newSelections = [
+            {
+                range: {
+                    startRowIndex: 1,
+                    startColumnIndex: firstColumnIndex,
+                    endColumnIndex: firstColumnIndex + columnIndexes.length - 1,
+                    endRowIndex: rowCount,
+                },
+            },
+        ];
+        // Add to sheets
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    if (!sheet.columnMetadata) {
+                        sheet.columnMetadata = [];
+                    }
+                    for (const columnIndex of columnIndexes) {
+                        if (!sheet.columnMetadata[columnIndex]) {
+                            sheet.columnMetadata[columnIndex] =
+                                {};
+                        }
+                        sheet.columnMetadata[columnIndex].hiddenByUser = false;
+                    }
+                }
+            });
+            // Save to history
+            saveHistory({
+                sheets: { patches, inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+            });
+            return nextState;
+        });
+        // Change active cell
+        onChangeActiveCell(sheetId, newActiveCell);
+        // Change selections
+        onChangeSelections(sheetId, newSelections);
+        onCommand?.({
+            command: "show-column",
+            sheetId,
+            columnIndexes,
+        });
+    }, [
+        rowCount,
+        createHistory,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheets,
+        getNextFocusableCell,
+        canEditSheet,
+        canPerformSheetAction,
+        showError,
+        onCommand,
+    ]);
+};