@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,131 @@
+import { useGetSheetDimensions } from "@rowsncolumns/spreadsheet";
+import { getImageDimensionsFromUrl, readImageFileAsDataUri, } from "@rowsncolumns/toolkit";
+import { log, uuid } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export const useOnInsertImage = ({ locale, idCreationStrategy, enqueueCalculation, createHistory, onChangeEmbeds, onChangeSheetData, onCommand, }) => {
+    const getSheetDimensions = useGetSheetDimensions();
+    return useCallback(async (fileOrUrl, sheetId, activeCell, options) => {
+        const { insertOverCells, embedId } = options ?? {};
+        const maxDimension = 800;
+        const [imageUrl, width, height] = fileOrUrl instanceof File
+            ? await readImageFileAsDataUri(fileOrUrl)
+            : [
+                fileOrUrl,
+                ...(await getImageDimensionsFromUrl(fileOrUrl)),
+            ];
+        const ratio = width / height;
+        const [sheetWidth = maxDimension] = getSheetDimensions?.() ?? [];
+        const finalWidth = Math.min(width, Math.min(sheetWidth, maxDimension));
+        const finalHeight = finalWidth / ratio;
+        // Recalc cells
+        const recalcCells = new Map();
+        const saveHistory = createHistory();
+        // Insert over cells => Embeds
+        if (insertOverCells) {
+            log("Added file to cell location: ", activeCell);
+            // Embeds
+            onChangeEmbeds?.((prevEmbeds) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
+                    if (!draft) {
+                        draft = [];
+                    }
+                    const embed = {
+                        embedId: idCreationStrategy?.("embed") ?? uuid(),
+                        position: {
+                            sheetId,
+                            overlayPosition: {
+                                anchorCell: activeCell,
+                                widthPixels: finalWidth,
+                                heightPixels: finalHeight,
+                                offsetXPixels: 0,
+                                offsetYPixels: 0,
+                            },
+                        },
+                        borderColor: "transparent",
+                        lockAspectRatio: true,
+                        spec: {
+                            type: "image",
+                            imageUrl,
+                        },
+                    };
+                    if (embedId) {
+                        const idx = draft.findIndex((cur) => cur.embedId === embedId);
+                        if (idx !== -1) {
+                            const currentEmbed = draft[idx];
+                            draft[idx] = {
+                                ...currentEmbed,
+                                spec: {
+                                    ...currentEmbed.spec,
+                                    imageUrl,
+                                },
+                            };
+                        }
+                    }
+                    else {
+                        draft.push(embed);
+                    }
+                });
+                saveHistory({
+                    embeds: { patches, inversePatches },
+                });
+                return nextState;
+            });
+        }
+        else {
+            // Update sheet data
+            onChangeSheetData?.((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                    const { rowIndex, columnIndex } = activeCell;
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    const sheetCell = new SheetCell();
+                    // Add update
+                    sheetCell.assign(sheetId, activeCell, currentSheet[rowIndex].values?.[columnIndex], { locale });
+                    sheetCell.setImage(imageUrl);
+                    currentSheet[rowIndex].values[columnIndex] =
+                        sheetCell.getCellData();
+                    // Enquee calculation
+                    enqueueCalculation({
+                        position: { rowIndex, columnIndex, sheetId },
+                        type: "add",
+                    });
+                    // Add to recalc cells
+                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                        rowIndex,
+                        columnIndex,
+                        sheetId,
+                    });
+                });
+                // Save history
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                    activeCell: { undo: activeCell, redo: activeCell },
+                    recalcCells: { undo: recalcCells, redo: recalcCells },
+                });
+                return nextState;
+            });
+        }
+        onCommand?.({
+            command: "insert-image",
+            sheetId,
+            activeCell,
+            imageUrl,
+            width: finalWidth,
+            height: finalHeight,
+            insertOverCells,
+            embedId,
+        });
+    }, [
+        locale,
+        idCreationStrategy,
+        createHistory,
+        enqueueCalculation,
+        getSheetDimensions,
+        onChangeEmbeds,
+        onChangeSheetData,
+        onCommand,
+    ]);
+};

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

@@ -0,0 +1,25 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { SelectionArea } from "@rowsncolumns/common-types";
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { CalculationOperation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+import { CellXfsRegistry } from "./use-cellxfs-registry";
+import { SharedStringRegistry } from "./use-ss-registry";
+import { useSheetProperties } from "./use-sheet-properties";
+type UseOnInsertLinkProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    getDataValidationById: ReturnType<typeof useSheetProperties>["getDataValidationById"];
+    enqueueCalculation(operation: CalculationOperation): void;
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    getSheetId: ReturnType<typeof useSheetProperties>["getSheetId"];
+    onCommand?: OnCommand;
+};
+export declare const useOnInsertLink: <T extends CellData, S extends Sheet>({ locale, getDataValidationById, cellXfsRegistry, sharedStringRegistry, onChangeSheetData, createHistory, enqueueCalculation, getSheetId, onCommand, }: UseOnInsertLinkProps<T, S>) => readonly [(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[] | undefined, url: string, title?: string) => void, (sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[]) => void, (sheetId: number, activeCell: CellInterface, hyperlink: T["hyperlink"]) => void];
+export {};
+//# sourceMappingURL=use-on-insert-link.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-insert-link.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-insert-link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,OAAO,EAGL,KAAK,QAAQ,EACb,KAAK,KAAK,EACX,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAYrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,KAAK,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC/D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,qBAAqB,EAAE,UAAU,CAC/B,OAAO,kBAAkB,CAC1B,CAAC,uBAAuB,CAAC,CAAC;IAC3B,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC1D,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,UAAU,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,YAAY,CAAC,CAAC;IAChE,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AACF,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,wJAUlE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,yBAKd,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE,GAAG,SAAS,OACvD,MAAM,UACJ,MAAM,qBAwHJ,MAAM,cACH,aAAa,eACZ,aAAa,CAAC,mBAAmB,CAAC,EAAE,qBA2GzC,MAAM,cAAc,aAAa,aAAa,CAAC,CAAC,WAAW,CAAC,UA6BzE,CAAC"}

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

@@ -0,0 +1,193 @@
+import { selectionFromActiveCell } from "@rowsncolumns/grid";
+import { useGetSelectionsFromFormula, useNavigateToSheetRange, } from "@rowsncolumns/spreadsheet";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+import { canUseDOM, normalizeExternalUrl } from "@rowsncolumns/utils";
+export const useOnInsertLink = ({ locale, getDataValidationById, cellXfsRegistry, sharedStringRegistry, onChangeSheetData, createHistory, enqueueCalculation, getSheetId, onCommand, }) => {
+    const canPerformSheetAction = useCanPerformSheetAction();
+    const showError = useShowError();
+    const onInsertHyperLink = useCallback((sheetId, activeCell, selections, url, title = url) => {
+        if (!canPerformSheetAction(sheetId, "insertHyperlinks")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't insert links on a protected sheet.",
+            });
+            return;
+        }
+        const saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        const sheetCell = new SheetCell();
+        const finalSelections = selections?.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        // Update sheets
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                for (const selection of finalSelections) {
+                    for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                            const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                            // Create a cell
+                            sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                                locale,
+                                cellXfsRegistry,
+                                sharedStringRegistry,
+                                getDataValidationById,
+                            });
+                            // Add url
+                            sheetCell.setUrl(url, title);
+                            // Register cell
+                            sharedStringRegistry?.registerCell(sheetCell);
+                            // Set cell data
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            // Enqueue
+                            enqueueCalculation({
+                                position: { rowIndex, columnIndex, sheetId },
+                                type: "add",
+                            });
+                            // Add to recalc cells
+                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                rowIndex,
+                                columnIndex,
+                                sheetId,
+                            });
+                        }
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                activeCell: { undo: activeCell, redo: activeCell },
+                selections: { undo: selections, redo: selections },
+                sheetId: { undo: sheetId, redo: sheetId },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Save hustory
+        sharedStringRegistry?.getPatches(saveHistory);
+        onCommand?.({
+            command: "insert-link",
+            sheetId,
+            activeCell,
+            selections,
+            url,
+            title,
+        });
+    }, [
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDataValidationById,
+        onChangeSheetData,
+        createHistory,
+        enqueueCalculation,
+        onCommand,
+        canPerformSheetAction,
+        showError,
+    ]);
+    const onRemoveLink = useCallback((sheetId, activeCell, selections) => {
+        const saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        const sheetCell = new SheetCell();
+        const finalSelections = selections?.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        // Update sheets
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                for (const selection of finalSelections) {
+                    for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                            const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                            // Create a cell
+                            sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                                locale,
+                                cellXfsRegistry,
+                                sharedStringRegistry,
+                                getDataValidationById,
+                            });
+                            // Add url
+                            sheetCell.deleteUrl();
+                            // Set cell data
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            // Enqueue
+                            enqueueCalculation({
+                                position: { rowIndex, columnIndex, sheetId },
+                                type: "add",
+                            });
+                            // Add to recalc cells
+                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                rowIndex,
+                                columnIndex,
+                                sheetId,
+                            });
+                        }
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                activeCell: { undo: activeCell, redo: activeCell },
+                selections: { undo: selections, redo: selections },
+                sheetId: { undo: sheetId, redo: sheetId },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        onCommand?.({
+            command: "remove-link",
+            sheetId,
+            activeCell,
+            selections,
+        });
+    }, [
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDataValidationById,
+        onChangeSheetData,
+        createHistory,
+        enqueueCalculation,
+        onCommand,
+    ]);
+    /**
+     * User selects a link
+     */
+    const getSelectionsFromFormula = useGetSelectionsFromFormula();
+    const navigateToSheetRange = useNavigateToSheetRange();
+    const onSelectLink = useCallback((sheetId, activeCell, hyperlink) => {
+        if (!canUseDOM)
+            return;
+        if (typeof hyperlink === "string" || hyperlink?.kind === "external") {
+            // External urls
+            const url = typeof hyperlink === "string" ? hyperlink : hyperlink?.url;
+            if (url) {
+                window.open(normalizeExternalUrl(url), "_blank");
+                return;
+            }
+        }
+        else if (hyperlink) {
+            const range = getSelectionsFromFormula?.(hyperlink.location, activeCell);
+            if (!range)
+                return;
+            const { sheetName, range: selectionRange } = range[0];
+            const newSheetId = sheetName ? getSheetId(sheetName) : sheetId;
+            navigateToSheetRange?.({ sheetId: newSheetId, ...selectionRange }, { enableFlash: false });
+        }
+    }, [getSheetId, getSelectionsFromFormula, navigateToSheetRange]);
+    return [onInsertHyperLink, onRemoveLink, onSelectLink];
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-insert-note.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-insert-note.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAMrE,eAAO,MAAM,eAAe,kBAMX,MAAM,QACT,aAAa,cACP,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAavD,CAAC"}

package/dist/esm/hooks/use-on-insert-note.js

@@ -0,0 +1,14 @@
+import { useCallbackRef, useInsertNote } from "@rowsncolumns/spreadsheet";
+import { useCallback } from "react";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export const useOnInsertNote = () => {
+    const onInsertNote = useInsertNote();
+    const canEditSheet = useCanEditSheet();
+    return useCallbackRef(useCallback((sheetId, cell, selections) => {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        return onInsertNote?.(sheetId, cell, selections);
+    }, [onInsertNote, canEditSheet]));
+};

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

@@ -0,0 +1,38 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { useCalculation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnInsertRowProps<T extends CellData, S extends Sheet> = {
+    rowCount: number;
+    columnCount: number;
+    locale?: string;
+    maxRowCount?: number;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    getGraphNodes?: ReturnType<typeof useCalculation>["getGraphNodes"];
+    getGraphNodesInSheet?: ReturnType<typeof useCalculation>["getGraphNodesInSheet"];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    enqueueCalculation?: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueStructureChange?: ReturnType<typeof useCalculation>["enqueueStructureChange"];
+    enqueueGraphOperation?: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    getActiveCell: () => CellInterface;
+    getSelections(): SelectionArea<SelectionAttributes>[];
+    getSheetName(sheetId: number): string;
+    enableInsertRowTimingLogs?: boolean;
+    onChangeSheetData?: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeSheets?: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeTables?: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeDataValidations?: UseSpreadsheetProps<T, S>["onChangeDataValidations"];
+    onChangeConditionalFormats?: UseSpreadsheetProps<T, S>["onChangeConditionalFormats"];
+    onChangeCitations?: UseSpreadsheetProps<T, S>["onChangeCitations"];
+    onChangePivotTables?: UseSpreadsheetProps<T, S>["onChangePivotTables"];
+    onCommand?: OnCommand;
+};
+export declare const useOnInsertRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, maxRowCount, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, getSheetName, enableInsertRowTimingLogs, onCommand, }: UseOnInsertRowProps<T, S>) => (sheetId: number, referenceRowIndex: number, numRows?: number) => void;
+//# sourceMappingURL=use-on-insert-row.d.ts.map

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

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

package/dist/esm/hooks/use-on-insert-row.js

@@ -0,0 +1,104 @@
+import { isNil } from "@rowsncolumns/utils";
+import { useCallback } from "react";
+import { useShowError } from "../atoms/error-state.atom";
+import { insertRow } from "../interface/insert-row";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditSheet, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export const useOnInsertRow = ({ rowCount, columnCount, locale, maxRowCount, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, getSheetName, enableInsertRowTimingLogs, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    const canPerformSheetAction = useCanPerformSheetAction();
+    const showError = useShowError();
+    return useCallback((sheetId, referenceRowIndex, numRows = 1) => {
+        const now = typeof performance !== "undefined" &&
+            typeof performance.now === "function"
+            ? performance.now.bind(performance)
+            : Date.now;
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        if (!canPerformSheetAction(sheetId, "insertRows")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't insert rows on a protected sheet.",
+            });
+            return;
+        }
+        if (!isNil(maxRowCount) && rowCount >= maxRowCount) {
+            showError({
+                title: "New rows cannot be added",
+                message: "You have reached the maximum number of rows.",
+            });
+            return;
+        }
+        // Inserts row
+        const startMs = now();
+        insertRow({
+            rowCount,
+            columnCount,
+            locale,
+            maxRowCount,
+            cellXfsRegistry,
+            sharedStringRegistry,
+            getActiveCell,
+            getSelections,
+            getDependents,
+            getGraphNodes,
+            getGraphNodesInSheet,
+            createHistory,
+            enqueueGraphOperation,
+            enqueueCalculation,
+            enqueueStructureChange,
+            onChangeSheetData,
+            onChangeSheets,
+            onChangeTables,
+            onChangeConditionalFormats,
+            onChangeDataValidations,
+            onChangeCitations,
+            onChangePivotTables,
+            getSheetName,
+        })(sheetId, referenceRowIndex, numRows);
+        const elapsedMs = now() - startMs;
+        if (enableInsertRowTimingLogs) {
+            console.debug("insert-row timings", {
+                sheetId,
+                referenceRowIndex,
+                numRows,
+                elapsedMs,
+            });
+        }
+        onCommand?.({
+            command: "insert-row",
+            sheetId,
+            referenceRowIndex,
+            numRows,
+        });
+    }, [
+        columnCount,
+        rowCount,
+        locale,
+        maxRowCount,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        showError,
+        getActiveCell,
+        getSelections,
+        getDependents,
+        getGraphNodes,
+        getGraphNodesInSheet,
+        createHistory,
+        onChangeSheets,
+        onChangeTables,
+        onChangeSheetData,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onChangePivotTables,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        canEditSheet,
+        canPerformSheetAction,
+        getSheetName,
+        enableInsertRowTimingLogs,
+        onCommand,
+    ]);
+};

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

@@ -0,0 +1,31 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { TableView } from "@rowsncolumns/spreadsheet";
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { useCalculation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnInsertTableRowProps<T extends CellData, S extends Sheet> = {
+    rowCount: number;
+    columnCount: number;
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueStructureChange?: ReturnType<typeof useCalculation>["enqueueStructureChange"];
+    enqueueGraphOperation: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeDataValidations?: UseSpreadsheetProps<T, S>["onChangeDataValidations"];
+    onChangeConditionalFormats?: UseSpreadsheetProps<T, S>["onChangeConditionalFormats"];
+    getActiveCell: () => CellInterface;
+    getSheetName(sheetId: number): string;
+    onCommand?: OnCommand;
+};
+export declare const useOnInsertTableRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, getSheetName, onCommand, }: UseOnInsertTableRowProps<T, S>) => (tableView: TableView, relativeRowIndex?: number, rowData?: Record<string, string | undefined | null>[]) => void;
+//# sourceMappingURL=use-on-insert-table-row.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-insert-table-row.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-insert-table-row.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAGtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,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,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,sBAAsB,CAAC,EAAE,UAAU,CACjC,OAAO,cAAc,CACtB,CAAC,wBAAwB,CAAC,CAAC;IAC5B,qBAAqB,EAAE,UAAU,CAC/B,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,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,uBAAuB,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC;IAC/E,0BAA0B,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,4BAA4B,CAAC,CAAC;IACrF,aAAa,EAAE,MAAM,aAAa,CAAC;IACnC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,4TAmBtE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,iBAIhB,SAAS,qBACD,MAAM,YACf,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,SA4D1D,CAAC"}

package/dist/esm/hooks/use-on-insert-table-row.js

@@ -0,0 +1,59 @@
+import { useCallback } from "react";
+import { insertTableRow } from "../interface/insert-table-row";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export const useOnInsertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, getSheetName, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    return useCallback((tableView, relativeRowIndex, rowData) => {
+        const { sheetId } = tableView;
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        // Insert table row
+        insertTableRow({
+            rowCount,
+            columnCount,
+            locale,
+            cellXfsRegistry,
+            sharedStringRegistry,
+            getActiveCell,
+            getDependents,
+            createHistory,
+            enqueueGraphOperation,
+            enqueueCalculation,
+            enqueueStructureChange,
+            onChangeSheetData,
+            onChangeSheets,
+            onChangeTables,
+            onChangeConditionalFormats,
+            onChangeDataValidations,
+            getSheetName,
+        })(tableView, relativeRowIndex, rowData);
+        onCommand?.({
+            command: "insert-table-row",
+            tableView,
+            relativeRowIndex,
+            rowData,
+        });
+    }, [
+        columnCount,
+        rowCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getActiveCell,
+        getDependents,
+        createHistory,
+        onChangeSheets,
+        onChangeTables,
+        onChangeSheetData,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        canEditSheet,
+        getSheetName,
+        onCommand,
+    ]);
+};

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

@@ -0,0 +1,4 @@
+export declare const useOnInsertTime: ({ locale }?: {
+    locale?: string;
+}) => (sheetId: number, activeCell: import("@rowsncolumns/grid").CellInterface, selections: import("@rowsncolumns/grid").SelectionArea<import("@rowsncolumns/spreadsheet").SelectionAttributes>[]) => void;
+//# sourceMappingURL=use-on-insert-time.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-insert-time.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-insert-time.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe,GAAI,aAAY;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,yMAUnE,CAAC"}

package/dist/esm/hooks/use-on-insert-time.js

@@ -0,0 +1,11 @@
+import { useSpreadsheet } from "@rowsncolumns/spreadsheet";
+import { getDefaultTimeFormat, ssfFormat } from "@rowsncolumns/utils";
+import { useCallback } from "react";
+export const useOnInsertTime = ({ locale } = {}) => {
+    const { makeEditable } = useSpreadsheet();
+    return useCallback((sheetId, activeCell) => {
+        const now = new Date();
+        const time = ssfFormat(getDefaultTimeFormat(locale, "minute"), now, locale);
+        makeEditable?.(sheetId, activeCell, time);
+    }, [locale, makeEditable]);
+};