@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-on-drag-n-drop.d.ts

@@ -0,0 +1,55 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { CalculationOperation } from "./use-calculation";
+import type { useCalculationInitialize } from "./use-calculation-initialize";
+import type { useOnImportCSV } from "./use-on-import-csv";
+import type { useOnImportExcelFile } from "./use-on-import-excel";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnDragnDropProps<T extends CellData, S extends Sheet> = {
+    sheetId: number;
+    enable?: boolean;
+    enableExcelfileDragDrop?: boolean;
+    locale?: string;
+    fileSizeLimit?: number;
+    getActiveCell(): CellInterface;
+    onChangeActiveCell(sheetId: number, cell: CellInterface): void;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeEmbeds?: UseSpreadsheetProps<T, S>["onChangeEmbeds"];
+    onIterativeCalculationEnabled?: UseSpreadsheetProps<T, S>["onIterativeCalculationEnabled"];
+    createHistory: (callback?: () => void) => (patches: SpreadsheetPatch) => void;
+    enqueueCalculation(operation: CalculationOperation): void;
+    onFileDrop?(files: FileList): void;
+    onError?(message: string): void;
+    importExcelFile: ReturnType<typeof useOnImportExcelFile>["importExcelFile"];
+    importCSVFile: ReturnType<typeof useOnImportCSV>["importCSVFile"];
+    calculateNow: ReturnType<typeof useCalculationInitialize>["calculateNow"];
+    enableCellXfsRegistry?: boolean;
+    enabledSharedStrings?: boolean;
+    onConfirm?: UseSpreadsheetProps["onConfirm"];
+    onPrompt?: UseSpreadsheetProps["onPrompt"];
+};
+export type InsertFileOptions = {
+    preserveFormatting?: boolean;
+    insertOverCells?: boolean;
+    minRowCount?: number;
+    minColumnCount?: number;
+    replaceSheetData?: boolean;
+    enabledSharedStrings?: boolean;
+    enableCellXfsRegistry?: boolean;
+    /**
+     * Custom confirm dialog function
+     */
+    confirm?: UseSpreadsheetProps["onConfirm"];
+    /**
+     * Custom prompt dialog function
+     */
+    prompt?: UseSpreadsheetProps["onPrompt"];
+};
+export declare const useOnDragnDrop: <T extends CellData, S extends Sheet>({ sheetId: activeSheetId, enable, enableExcelfileDragDrop, locale, fileSizeLimit, getActiveCell, onIterativeCalculationEnabled, onChangeActiveCell, onChangeSheetData, enqueueCalculation, createHistory, onError, onChangeEmbeds, importExcelFile, importCSVFile, calculateNow, enableCellXfsRegistry, enabledSharedStrings, onConfirm, onPrompt, }: UseOnDragnDropProps<T, S>) => {
+    onDragOver: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDrop: (e: React.DragEvent<HTMLDivElement>) => Promise<void>;
+    onInsertFile: (file: File, sheetIdToInsert?: number, activeCell?: CellInterface, options?: InsertFileOptions) => Promise<void>;
+};
+export {};
+//# sourceMappingURL=use-on-drag-n-drop.d.ts.map

package/dist/cjs/hooks/use-on-drag-n-drop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-drag-n-drop.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-drag-n-drop.ts"],"names":[],"mappings":"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"}

package/dist/cjs/hooks/use-on-drag-n-drop.js

@@ -0,0 +1,191 @@
+import { __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { isEqualCells } from "@rowsncolumns/grid";
+import { useGetCellCoordsFromOffset, useLoadingIndicator, useScrollToCell, } from "@rowsncolumns/spreadsheet";
+import { SUPPORTED_FILE_TYPES } from "@rowsncolumns/toolkit";
+import { useCallback } from "react";
+import { useOnInsertImage } from "./use-on-insert-image";
+export var useOnDragnDrop = function (_a) {
+    var activeSheetId = _a.sheetId, enable = _a.enable, _b = _a.enableExcelfileDragDrop, enableExcelfileDragDrop = _b === void 0 ? true : _b, locale = _a.locale, _c = _a.fileSizeLimit, fileSizeLimit = _c === void 0 ? 50 * 1024 * 1024 : _c, // 50MB Limit
+    getActiveCell = _a.getActiveCell, onIterativeCalculationEnabled = _a.onIterativeCalculationEnabled, onChangeActiveCell = _a.onChangeActiveCell, onChangeSheetData = _a.onChangeSheetData, enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onError = _a.onError, onChangeEmbeds = _a.onChangeEmbeds, importExcelFile = _a.importExcelFile, importCSVFile = _a.importCSVFile, calculateNow = _a.calculateNow, enableCellXfsRegistry = _a.enableCellXfsRegistry, enabledSharedStrings = _a.enabledSharedStrings, onConfirm = _a.onConfirm, onPrompt = _a.onPrompt;
+    var scrollToCell = useScrollToCell();
+    var getCellCoordsFromOffset = useGetCellCoordsFromOffset();
+    var _d = __read(useLoadingIndicator(), 2), showLoader = _d[0], hideLoader = _d[1];
+    // Insert image
+    var onInsertImage = useOnInsertImage({
+        locale: locale,
+        onChangeEmbeds: onChangeEmbeds,
+        onChangeSheetData: onChangeSheetData,
+        enqueueCalculation: enqueueCalculation,
+        createHistory: createHistory,
+    });
+    var onDragOver = useCallback(function (e) {
+        if (!enable) {
+            return;
+        }
+        e.preventDefault();
+        // User is not dragging on to a cell
+        var activeCell = getCellCoordsFromOffset === null || getCellCoordsFromOffset === void 0 ? void 0 : getCellCoordsFromOffset(e.clientX, e.clientY, false);
+        // Ignore row headers
+        if ((activeCell === null || activeCell === void 0 ? void 0 : activeCell.rowIndex) === 0 || (activeCell === null || activeCell === void 0 ? void 0 : activeCell.columnIndex) === 0) {
+            return;
+        }
+        if (activeCell && !isEqualCells(activeCell, getActiveCell())) {
+            onChangeActiveCell === null || onChangeActiveCell === void 0 ? void 0 : onChangeActiveCell(activeSheetId, activeCell);
+            scrollToCell === null || scrollToCell === void 0 ? void 0 : scrollToCell(activeCell);
+        }
+    }, [
+        enable,
+        activeSheetId,
+        onChangeActiveCell,
+        getActiveCell,
+        getCellCoordsFromOffset,
+        scrollToCell,
+    ]);
+    // Process single file
+    var onInsertFile = useCallback(
+    /**
+     * @param file - The file to be inserted
+     * @param sheetIdToInsert - ID of the sheet where the file should be inserted (defaults to activeSheetId)
+     * @param activeCell - The currently active cell where insertion will occur (defaults to getActiveCell())
+     * @param options - Configuration options for file insertion
+     */
+    function (file_1) {
+        var args_1 = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args_1[_i - 1] = arguments[_i];
+        }
+        return __awaiter(void 0, __spreadArray([file_1], __read(args_1), false), void 0, function (file, sheetIdToInsert, activeCell, options) {
+            var _a, insertOverCells, minColumnCount, minRowCount, _b, preserveFormatting, _c, replaceSheetData, enableCellXfsRegistryOption, enabledSharedStringsOption, sheetId, fileType, _d, _e, requiresRecalc, iterativeCalculationOptions, err_1;
+            var _f, _g, _h, _j;
+            if (sheetIdToInsert === void 0) { sheetIdToInsert = activeSheetId; }
+            if (activeCell === void 0) { activeCell = getActiveCell(); }
+            return __generator(this, function (_k) {
+                switch (_k.label) {
+                    case 0:
+                        _a = options !== null && options !== void 0 ? options : {}, insertOverCells = _a.insertOverCells, minColumnCount = _a.minColumnCount, minRowCount = _a.minRowCount, _b = _a.preserveFormatting, preserveFormatting = _b === void 0 ? true : _b, _c = _a.replaceSheetData, replaceSheetData = _c === void 0 ? false : _c;
+                        enableCellXfsRegistryOption = (_f = options === null || options === void 0 ? void 0 : options.enableCellXfsRegistry) !== null && _f !== void 0 ? _f : enableCellXfsRegistry;
+                        enabledSharedStringsOption = (_g = options === null || options === void 0 ? void 0 : options.enabledSharedStrings) !== null && _g !== void 0 ? _g : enabledSharedStrings;
+                        sheetId = sheetIdToInsert !== null && sheetIdToInsert !== void 0 ? sheetIdToInsert : activeSheetId;
+                        // We need to track this for history. Precedent cells
+                        if (file.size > fileSizeLimit) {
+                            onError === null || onError === void 0 ? void 0 : onError("File size exceeds the limit of ".concat(fileSizeLimit / 1000000, " mb"));
+                            return [2 /*return*/];
+                        }
+                        fileType = file.type.toLowerCase();
+                        _d = fileType;
+                        switch (_d) {
+                            case SUPPORTED_FILE_TYPES.XLSB: return [3 /*break*/, 1];
+                            case SUPPORTED_FILE_TYPES.XLSM: return [3 /*break*/, 1];
+                            case SUPPORTED_FILE_TYPES.ODS: return [3 /*break*/, 1];
+                            case SUPPORTED_FILE_TYPES.EXCEL: return [3 /*break*/, 1];
+                            case SUPPORTED_FILE_TYPES.CSV: return [3 /*break*/, 3];
+                            case SUPPORTED_FILE_TYPES.CSV_TAB_SEPARATED: return [3 /*break*/, 3];
+                            case "image/apng": return [3 /*break*/, 7];
+                            case "image/bmp": return [3 /*break*/, 7];
+                            case "image/gif": return [3 /*break*/, 7];
+                            case "image/jpeg": return [3 /*break*/, 7];
+                            case "image/pjpeg": return [3 /*break*/, 7];
+                            case "image/png": return [3 /*break*/, 7];
+                            case "image/svg+xml": return [3 /*break*/, 7];
+                            case "image/tiff": return [3 /*break*/, 7];
+                            case "image/webp": return [3 /*break*/, 7];
+                            case "image/x-icon": return [3 /*break*/, 7];
+                        }
+                        return [3 /*break*/, 9];
+                    case 1:
+                        if (!enableExcelfileDragDrop) {
+                            onError === null || onError === void 0 ? void 0 : onError("Excel file drag and drop is disabled.");
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, importExcelFile(file, {
+                                minRowCount: minRowCount,
+                                minColumnCount: minColumnCount,
+                                enableCellXfsRegistry: enableCellXfsRegistryOption,
+                                enabledSharedStrings: enabledSharedStringsOption,
+                                confirm: (_h = options === null || options === void 0 ? void 0 : options.confirm) !== null && _h !== void 0 ? _h : onConfirm,
+                                prompt: (_j = options === null || options === void 0 ? void 0 : options.prompt) !== null && _j !== void 0 ? _j : onPrompt,
+                            })];
+                    case 2:
+                        _e = _k.sent(), requiresRecalc = _e.requiresRecalc, iterativeCalculationOptions = _e.iterativeCalculationOptions;
+                        onIterativeCalculationEnabled === null || onIterativeCalculationEnabled === void 0 ? void 0 : onIterativeCalculationEnabled(Boolean(iterativeCalculationOptions === null || iterativeCalculationOptions === void 0 ? void 0 : iterativeCalculationOptions.enabled));
+                        calculateNow({
+                            disableEvaluation: !requiresRecalc,
+                            shouldResetCellDependencyGraph: true,
+                        });
+                        return [3 /*break*/, 10];
+                    case 3:
+                        _k.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, importCSVFile(file, sheetId, activeCell, {
+                                preserveFormatting: preserveFormatting,
+                                replaceSheetData: replaceSheetData,
+                                enabledSharedStrings: enabledSharedStringsOption,
+                                enableCellXfsRegistry: enableCellXfsRegistryOption,
+                            })];
+                    case 4:
+                        _k.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        err_1 = _k.sent();
+                        onError === null || onError === void 0 ? void 0 : onError(String(err_1));
+                        return [3 /*break*/, 6];
+                    case 6: return [3 /*break*/, 10];
+                    case 7:
+                        // Show loading indicator
+                        showLoader("Reading Image file.");
+                        return [4 /*yield*/, (onInsertImage === null || onInsertImage === void 0 ? void 0 : onInsertImage(file, activeSheetId, activeCell, {
+                                insertOverCells: insertOverCells,
+                            }))];
+                    case 8:
+                        _k.sent();
+                        // Hide laoding
+                        hideLoader();
+                        return [3 /*break*/, 10];
+                    case 9:
+                        onError === null || onError === void 0 ? void 0 : onError("File type is not supported for drag n drop.");
+                        _k.label = 10;
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    }, [
+        activeSheetId,
+        fileSizeLimit,
+        enableExcelfileDragDrop,
+        onInsertImage,
+        hideLoader,
+        showLoader,
+        getActiveCell,
+        onError,
+        enableCellXfsRegistry,
+        enabledSharedStrings,
+        importExcelFile,
+        importCSVFile,
+        calculateNow,
+        onIterativeCalculationEnabled,
+        onConfirm,
+        onPrompt,
+    ]);
+    // File drop handler
+    var onDrop = useCallback(function (e) { return __awaiter(void 0, void 0, void 0, function () {
+        var files, isEmbed;
+        return __generator(this, function (_a) {
+            if (!enable) {
+                return [2 /*return*/];
+            }
+            e.preventDefault();
+            files = e.dataTransfer.files;
+            if (files.length) {
+                isEmbed = e.shiftKey || e.ctrlKey;
+                onInsertFile(files[0], activeSheetId, getActiveCell(), {
+                    insertOverCells: isEmbed,
+                });
+            }
+            return [2 /*return*/];
+        });
+    }); }, [enable, activeSheetId, onInsertFile, getActiveCell]);
+    return {
+        onDragOver: onDragOver,
+        onDrop: onDrop,
+        onInsertFile: onInsertFile,
+    };
+};

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

@@ -0,0 +1,29 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { GeneratedNames } from "../generated-names";
+import type { CalculationOperation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnDuplicateSheetProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    maxSheetCount?: number;
+    sheets?: S[];
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    createHistory(): (patch: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeCharts: UseSpreadsheetProps<T, S>["onChangeCharts"];
+    onChangeEmbeds: UseSpreadsheetProps<T, S>["onChangeEmbeds"];
+    onChangeConditionalFormats: UseSpreadsheetProps<T, S>["onChangeConditionalFormats"];
+    onChangeDataValidations: UseSpreadsheetProps<T, S>["onChangeDataValidations"];
+    enqueueGraphOperation(operation: CalculationOperation): void;
+    onChangeActiveSheet(sheetId: number): void;
+    /**
+     * Id creation strategy
+     */
+    idCreationStrategy?: UseSpreadsheetProps["idCreationStrategy"];
+    onCommand?: OnCommand;
+    generatedNames?: GeneratedNames;
+};
+export declare const useOnDuplicateSheet: <T extends CellData, S extends Sheet>({ locale, maxSheetCount, sheets, idCreationStrategy, onChangeActiveSheet, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCharts, onChangeEmbeds, onChangeConditionalFormats, onChangeDataValidations, enqueueGraphOperation, createHistory, onCommand, generatedNames, }: UseOnDuplicateSheetProps<T, S>) => (sheetId: number) => void;
+//# sourceMappingURL=use-on-duplicate-sheet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-duplicate-sheet.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-duplicate-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;IACb,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,aAAa,IAAI,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACnD,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,0BAA0B,EAAE,mBAAmB,CAC7C,CAAC,EACD,CAAC,CACF,CAAC,4BAA4B,CAAC,CAAC;IAChC,uBAAuB,EAAE,mBAAmB,CAC1C,CAAC,EACD,CAAC,CACF,CAAC,yBAAyB,CAAC,CAAC;IAC7B,qBAAqB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC7D,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C;;OAEG;IACH,kBAAkB,CAAC,EAAE,mBAAmB,CAAC,oBAAoB,CAAC,CAAC;IAC/D,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sRAiBtE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,eAInB,MAAM,SA6DnB,CAAC"}

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

@@ -0,0 +1,65 @@
+import { isNil } from "@rowsncolumns/utils";
+import { useCallback } from "react";
+import { useShowError } from "../atoms";
+import { duplicateSheet } from "../interface/duplicate-sheet";
+import { useCanEditWorkbook } from "./use-can-edit-cellrange";
+export var useOnDuplicateSheet = function (_a) {
+    var locale = _a.locale, maxSheetCount = _a.maxSheetCount, sheets = _a.sheets, idCreationStrategy = _a.idCreationStrategy, onChangeActiveSheet = _a.onChangeActiveSheet, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeCharts = _a.onChangeCharts, onChangeEmbeds = _a.onChangeEmbeds, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, enqueueGraphOperation = _a.enqueueGraphOperation, createHistory = _a.createHistory, onCommand = _a.onCommand, generatedNames = _a.generatedNames;
+    var showError = useShowError();
+    var canEditWorkbook = useCanEditWorkbook();
+    return useCallback(function (sheetId) {
+        var _a;
+        if (!canEditWorkbook()) {
+            console.debug("Workbook is structurally protected, cannot duplicate a sheet.");
+            return;
+        }
+        if (!isNil(maxSheetCount) && ((_a = sheets === null || sheets === void 0 ? void 0 : sheets.length) !== null && _a !== void 0 ? _a : 0) + 1 > maxSheetCount) {
+            showError({
+                title: "New sheets cannot be added.",
+                message: "You have reached the maximum number of sheets.",
+            });
+            return;
+        }
+        var newSheetId = duplicateSheet({
+            locale: locale,
+            maxSheetCount: maxSheetCount,
+            sheets: sheets,
+            idCreationStrategy: idCreationStrategy,
+            onChangeActiveSheet: onChangeActiveSheet,
+            onChangeSheetData: onChangeSheetData,
+            onChangeSheets: onChangeSheets,
+            onChangeTables: onChangeTables,
+            onChangeCharts: onChangeCharts,
+            onChangeEmbeds: onChangeEmbeds,
+            onChangeConditionalFormats: onChangeConditionalFormats,
+            onChangeDataValidations: onChangeDataValidations,
+            enqueueGraphOperation: enqueueGraphOperation,
+            createHistory: createHistory,
+            generatedNames: generatedNames,
+        })(sheetId);
+        // Update active sheet only if duplication succeeded
+        if (newSheetId !== undefined) {
+            onChangeActiveSheet(newSheetId);
+        }
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "duplicate-sheet", sheetId: sheetId });
+    }, [
+        locale,
+        sheets,
+        maxSheetCount,
+        showError,
+        idCreationStrategy,
+        onChangeActiveSheet,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        onChangeCharts,
+        onChangeEmbeds,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        createHistory,
+        enqueueGraphOperation,
+        canEditWorkbook,
+        onCommand,
+        generatedNames,
+    ]);
+};

package/dist/cjs/hooks/use-on-embeds.d.ts

@@ -0,0 +1,19 @@
+import type { EmbeddedObject } from "@rowsncolumns/spreadsheet";
+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 UseOnEmbedsProps<T extends CellData> = {
+    onChangeEmbeds: UseSpreadsheetProps<T>["onChangeEmbeds"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnEmbeds: <T extends CellData>({ onChangeEmbeds, createHistory, onCommand, }: UseOnEmbedsProps<T>) => {
+    onDeleteEmbed: (embedId: string | number) => void;
+    onMoveEmbed: (embedId: string | number, sheetId: number, anchorCell: import("@rowsncolumns/grid").CellInterface, offsetXPixels: number, offsetYPixels: number) => void;
+    onResizeEmbed: (embedId: string | number, sheetId: number, anchorCell: import("@rowsncolumns/grid").CellInterface, offsetXPixels: number, offsetYPixels: number, width: number, height: number) => void;
+    onCreateEmbed: (spec: EmbeddedObject) => void;
+    onUpdateEmbed: (embed: EmbeddedObject) => void;
+    onRequestEditEmbed: (embed: EmbeddedObject) => void;
+};
+//# sourceMappingURL=use-on-embeds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-embeds.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-embeds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQ7C,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,IAAI;IACjD,cAAc,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IACzD,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,+CAI7C,gBAAgB,CAAC,CAAC,CAAC;;;;0BAyGX,cAAc;2BA/Eb,cAAc;gCA4Fd,cAAc;CAezB,CAAC"}

package/dist/cjs/hooks/use-on-embeds.js

@@ -0,0 +1,87 @@
+import { useFocusSheet, } from "@rowsncolumns/spreadsheet";
+import { useCallback } from "react";
+import { useSetEditEmbedDialogState, useSetEditingEmbed } from "../atoms";
+import { createEmbed, deleteEmbed, moveEmbed, resizeEmbed, updateEmbed, } from "../interface/embeds";
+export var useOnEmbeds = function (_a) {
+    var onChangeEmbeds = _a.onChangeEmbeds, createHistory = _a.createHistory, onCommand = _a.onCommand;
+    var focusSheet = useFocusSheet();
+    var setEditEmbedDialogState = useSetEditEmbedDialogState();
+    var setEditEmbed = useSetEditingEmbed();
+    // Delete
+    var onDeleteEmbed = useCallback(function (embedId) {
+        if (onChangeEmbeds) {
+            deleteEmbed({
+                onChangeEmbeds: onChangeEmbeds,
+                createHistory: createHistory,
+            })(embedId);
+        }
+        focusSheet === null || focusSheet === void 0 ? void 0 : focusSheet();
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "delete-embed", embedId: embedId });
+    }, [onChangeEmbeds, createHistory, focusSheet, onCommand]);
+    // Update
+    var onUpdateEmbed = useCallback(function (embed) {
+        if (onChangeEmbeds) {
+            updateEmbed({
+                onChangeEmbeds: onChangeEmbeds,
+                createHistory: createHistory,
+            })(embed);
+        }
+        focusSheet === null || focusSheet === void 0 ? void 0 : focusSheet();
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "update-embed", embed: embed });
+    }, [onChangeEmbeds, createHistory, focusSheet, onCommand]);
+    var onMoveEmbed = useCallback(function (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels) {
+        if (onChangeEmbeds) {
+            moveEmbed({
+                onChangeEmbeds: onChangeEmbeds,
+                createHistory: createHistory,
+            })(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels);
+        }
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "move-embed",
+            embedId: embedId,
+            sheetId: sheetId,
+            anchorCell: anchorCell,
+            offsetXPixels: offsetXPixels,
+            offsetYPixels: offsetYPixels,
+        });
+    }, [onChangeEmbeds, createHistory, onCommand]);
+    var onResizeEmbed = useCallback(function (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) {
+        if (onChangeEmbeds) {
+            resizeEmbed({
+                onChangeEmbeds: onChangeEmbeds,
+                createHistory: createHistory,
+            })(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height);
+        }
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "resize-embed",
+            embedId: embedId,
+            sheetId: sheetId,
+            anchorCell: anchorCell,
+            offsetXPixels: offsetXPixels,
+            offsetYPixels: offsetYPixels,
+            width: width,
+            height: height,
+        });
+    }, [onChangeEmbeds, createHistory, onCommand]);
+    // Create embed
+    var onCreateEmbed = useCallback(function (spec) {
+        createEmbed({
+            createHistory: createHistory,
+            onChangeEmbeds: onChangeEmbeds,
+        })(spec);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "create-embed", spec: spec });
+    }, [onChangeEmbeds, createHistory, onCommand]);
+    // Request edit embed
+    var onRequestEditEmbed = useCallback(function (embed) {
+        setEditEmbedDialogState(true);
+        setEditEmbed(embed);
+    }, [setEditEmbedDialogState, setEditEmbed]);
+    return {
+        onDeleteEmbed: onDeleteEmbed,
+        onMoveEmbed: onMoveEmbed,
+        onResizeEmbed: onResizeEmbed,
+        onCreateEmbed: onCreateEmbed,
+        onUpdateEmbed: onUpdateEmbed,
+        onRequestEditEmbed: onRequestEditEmbed,
+    };
+};

package/dist/cjs/hooks/use-on-expand-column-group.d.ts

@@ -0,0 +1,11 @@
+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 UseOnExpandColumnGroupProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onCommand?: OnCommand;
+};
+export declare const useOnExpandColumnGroup: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onCommand, }: UseOnExpandColumnGroupProps<T, S>) => (sheetId: number, summaryColumnIndex: number) => void;
+//# sourceMappingURL=use-on-expand-column-group.d.ts.map

package/dist/cjs/hooks/use-on-expand-column-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-expand-column-group.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-expand-column-group.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,2BAA2B,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC7E,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,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAIzE,2BAA2B,CAAC,CAAC,EAAE,CAAC,CAAC,eAGtB,MAAM,sBAAsB,MAAM,SA8C/C,CAAC"}

package/dist/cjs/hooks/use-on-expand-column-group.js

@@ -0,0 +1,45 @@
+import { __read } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { findGroupAtSummary, resolveSummaryRight } from "../api/outline";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export var useOnExpandColumnGroup = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, summaryColumnIndex) {
+        if (!canEditSheet(sheetId))
+            return;
+        var saveHistory = createHistory();
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (!sheet) {
+                    return;
+                }
+                if (!sheet.columnMetadata) {
+                    sheet.columnMetadata = [];
+                }
+                var summaryRight = resolveSummaryRight((_a = sheet.outlinePr) !== null && _a !== void 0 ? _a : undefined);
+                var group = findGroupAtSummary(sheet.columnMetadata, summaryColumnIndex, summaryRight);
+                if (!group)
+                    return;
+                for (var c = group.startIndex; c <= group.endIndex; c++) {
+                    var meta = sheet.columnMetadata[c];
+                    if (meta)
+                        delete meta.hiddenByGroup;
+                }
+                var summary = sheet.columnMetadata[summaryColumnIndex];
+                if (summary)
+                    delete summary.collapsed;
+            }), 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: "expand-column-group",
+            sheetId: sheetId,
+            summaryColumnIndex: summaryColumnIndex,
+        });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

package/dist/cjs/hooks/use-on-expand-row-group.d.ts

@@ -0,0 +1,18 @@
+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 UseOnExpandRowGroupProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onCommand?: OnCommand;
+};
+/**
+ * Expand the collapsed group whose summary sits at `summaryRowIndex`.
+ * Clears `hiddenByGroup` on every child + `collapsed` on the summary.
+ * Any `hiddenByUser` or `hiddenByFilter` flags survive, so rows the
+ * user manually hid before collapsing stay hidden afterwards (better
+ * than Excel, which conflates the two flags).
+ */
+export declare const useOnExpandRowGroup: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onCommand, }: UseOnExpandRowGroupProps<T, S>) => (sheetId: number, summaryRowIndex: number) => void;
+//# sourceMappingURL=use-on-expand-row-group.d.ts.map

package/dist/cjs/hooks/use-on-expand-row-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-expand-row-group.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-expand-row-group.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,wBAAwB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC1E,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;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAItE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,eAGnB,MAAM,mBAAmB,MAAM,SA8C5C,CAAC"}

package/dist/cjs/hooks/use-on-expand-row-group.js

@@ -0,0 +1,52 @@
+import { __read } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { findGroupAtSummary, resolveSummaryBelow } from "../api/outline";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+/**
+ * Expand the collapsed group whose summary sits at `summaryRowIndex`.
+ * Clears `hiddenByGroup` on every child + `collapsed` on the summary.
+ * Any `hiddenByUser` or `hiddenByFilter` flags survive, so rows the
+ * user manually hid before collapsing stay hidden afterwards (better
+ * than Excel, which conflates the two flags).
+ */
+export var useOnExpandRowGroup = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, summaryRowIndex) {
+        if (!canEditSheet(sheetId))
+            return;
+        var saveHistory = createHistory();
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (!sheet) {
+                    return;
+                }
+                if (!sheet.rowMetadata) {
+                    sheet.rowMetadata = [];
+                }
+                var summaryBelow = resolveSummaryBelow((_a = sheet.outlinePr) !== null && _a !== void 0 ? _a : undefined);
+                var group = findGroupAtSummary(sheet.rowMetadata, summaryRowIndex, summaryBelow);
+                if (!group)
+                    return;
+                for (var r = group.startIndex; r <= group.endIndex; r++) {
+                    var meta = sheet.rowMetadata[r];
+                    if (meta)
+                        delete meta.hiddenByGroup;
+                }
+                var summary = sheet.rowMetadata[summaryRowIndex];
+                if (summary)
+                    delete summary.collapsed;
+            }), 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: "expand-row-group",
+            sheetId: sheetId,
+            summaryRowIndex: summaryRowIndex,
+        });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

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

@@ -0,0 +1,9 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import { Direction } from "@rowsncolumns/grid";
+import type { SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { useOnFill } from "./use-on-fill";
+export type UseOnFillRangeProps = {
+    onFill: ReturnType<typeof useOnFill>;
+};
+export declare const useOnFillRange: ({ onFill }: UseOnFillRangeProps) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], direction: Direction | undefined) => void;
+//# sourceMappingURL=use-on-fill-range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-fill-range.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-fill-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,EAAE,SAAS,EAA2B,MAAM,oBAAoB,CAAC;AACxE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAGrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;CACtC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,YAAY,mBAAmB,eAG/C,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE,aACrC,SAAS,GAAG,SAAS,SAkGrC,CAAC"}