@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,49 @@
+import type { CellInterface, Direction, SelectionArea } from "@rowsncolumns/grid";
+import type { BandedDefinition, CanvasGridMethods, CellData, FilterView, SelectionAttributes, Sheet, SpreadsheetTheme, TableTheme, TableView } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { GeneratedNames } from "../generated-names";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { useCalculation } from "./use-calculation";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnTableProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    theme: SpreadsheetTheme;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueStructureChange?: ReturnType<typeof useCalculation>["enqueueStructureChange"];
+    enqueueGraphOperation: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    rowCount: number;
+    columnCount: number;
+    tables?: TableView[];
+    basicFilter?: FilterView | null;
+    /**
+     * Id creation strategy
+     */
+    idCreationStrategy?: UseSpreadsheetProps["idCreationStrategy"];
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    getEffectiveValue: ReturnType<typeof useSheetProperties>["getEffectiveValue"];
+    getFormattedValue: ReturnType<typeof useSheetProperties>["getFormattedValue"];
+    onRequestCalculate: ReturnType<typeof useCalculation>["onRequestCalculate"];
+    getContentfulRangeAroundCell: CanvasGridMethods["getContentfulGridRangeAroundCell"];
+    getSheetName(sheetId: number): string;
+    onCommand?: OnCommand;
+    generatedNames?: GeneratedNames;
+};
+export declare const useOnTable: <T extends CellData, S extends Sheet>({ locale, cellXfsRegistry, sharedStringRegistry, rowCount, columnCount, tables, basicFilter, theme: spreadsheetTheme, idCreationStrategy, enqueueCalculation, enqueueStructureChange, createHistory, onChangeSheets, onChangeTables, onChangeSheetData, getFormattedValue, getEffectiveValue, onRequestCalculate, getDependents, enqueueGraphOperation, getContentfulRangeAroundCell, getSheetName, onCommand, generatedNames, }: UseOnTableProps<T, S>) => {
+    onCreateTable: (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], tableSpec?: Partial<TableView>, theme?: TableTheme, bandedRange?: BandedDefinition) => void;
+    onRemoveTable: (tableView: TableView) => void;
+    onUpdateTable: (sheetId: number, tableId: TableView["id"], updatedTable: Partial<TableView>) => void;
+    onCreateBasicFilter: (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], basicFilterSpec?: Partial<FilterView>) => void;
+    onInsertTableColumn: (tableView: TableView, dimensionIndex: number, direction: Direction.Left | Direction.Right) => void;
+    onDeleteTableColumn: (tableView: TableView, dimensionIndex: number) => void;
+};
+export { addTableColumn } from "../interface/table-utils";
+//# sourceMappingURL=use-on-table.d.ts.map

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

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

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

@@ -0,0 +1,386 @@
+import { __assign, __awaiter, __generator, __read } from "tslib";
+import { areaIntersects, selectionFromActiveCell } from "@rowsncolumns/grid";
+import { isCellWithinBounds } from "@rowsncolumns/grid";
+import { uuid } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { getConfictingTable } from "../helpers";
+import { createTable } from "../interface/create-table";
+import { deleteTableColumn } from "../interface/delete-table-column";
+import { insertTableColumn } from "../interface/insert-column";
+import { removeTable } from "../interface/remove-table";
+import { updateTable } from "../interface/update-table";
+import { useShowError } from "./../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+import { getHiddenRowsFromFilterSpecs } from "./use-on-filter-table";
+export var useOnTable = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, rowCount = _a.rowCount, columnCount = _a.columnCount, tables = _a.tables, basicFilter = _a.basicFilter, spreadsheetTheme = _a.theme, idCreationStrategy = _a.idCreationStrategy, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeSheetData = _a.onChangeSheetData, getFormattedValue = _a.getFormattedValue, getEffectiveValue = _a.getEffectiveValue, onRequestCalculate = _a.onRequestCalculate, getDependents = _a.getDependents, enqueueGraphOperation = _a.enqueueGraphOperation, getContentfulRangeAroundCell = _a.getContentfulRangeAroundCell, getSheetName = _a.getSheetName, onCommand = _a.onCommand, generatedNames = _a.generatedNames;
+    var showError = useShowError();
+    var canPerformSheetAction = useCanPerformSheetAction();
+    // Create a new table
+    var onCreateTable = useCallback(function (sheetId, activeCell, selections, tableSpec, theme, bandedRange) {
+        // Validate
+        var lastSelection = selections === null || selections === void 0 ? void 0 : selections[selections.length - 1];
+        // Check basicFilter intersection
+        var basicFilterIntersects = basicFilter && areaIntersects(basicFilter.range, lastSelection === null || lastSelection === void 0 ? void 0 : lastSelection.range);
+        if (basicFilterIntersects) {
+            showError({
+                title: "Error",
+                message: "You cannot create a table that spans a filter.",
+            });
+            return;
+        }
+        // Check if this selection intersects
+        var tableIntersects = tables === null || tables === void 0 ? void 0 : tables.find(function (table) {
+            return areaIntersects(table.range, lastSelection === null || lastSelection === void 0 ? void 0 : lastSelection.range) &&
+                table.sheetId === sheetId;
+        });
+        if (tableIntersects) {
+            showError({
+                title: "Error",
+                message: "You cannot create a table that spans another table.",
+            });
+            return;
+        }
+        createTable({
+            locale: locale,
+            rowCount: rowCount,
+            columnCount: columnCount,
+            tables: tables,
+            basicFilter: basicFilter,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: sharedStringRegistry,
+            theme: spreadsheetTheme,
+            idCreationStrategy: idCreationStrategy,
+            enqueueCalculation: enqueueCalculation,
+            createHistory: createHistory,
+            onChangeSheets: onChangeSheets,
+            onChangeTables: onChangeTables,
+            onChangeSheetData: onChangeSheetData,
+            getFormattedValue: getFormattedValue,
+            getEffectiveValue: getEffectiveValue,
+            onRequestCalculate: onRequestCalculate,
+            getDependents: getDependents,
+            enqueueGraphOperation: enqueueGraphOperation,
+            getContentfulRangeAroundCell: getContentfulRangeAroundCell,
+            getSheetName: getSheetName,
+            generatedNames: generatedNames,
+        })(sheetId, activeCell, selections, tableSpec, theme, bandedRange);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "create-table",
+            sheetId: sheetId,
+            activeCell: activeCell,
+            selections: selections,
+            tableSpec: tableSpec,
+            theme: theme,
+            bandedRange: bandedRange,
+        });
+    }, [
+        locale,
+        tables,
+        basicFilter,
+        columnCount,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDependents,
+        getEffectiveValue,
+        onRequestCalculate,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        rowCount,
+        showError,
+        idCreationStrategy,
+        getContentfulRangeAroundCell,
+        createHistory,
+        onChangeTables,
+        onChangeSheets,
+        onChangeSheetData,
+        getFormattedValue,
+        getSheetName,
+        onCommand,
+        generatedNames,
+    ]);
+    // Remove table
+    var onRemoveTable = useCallback(function (tableView) {
+        removeTable({
+            onChangeTables: onChangeTables,
+            onChangeSheets: onChangeSheets,
+            createHistory: createHistory,
+            getDependents: getDependents,
+            enqueueCalculation: enqueueCalculation,
+        })(tableView);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "remove-table", tableView: tableView });
+    }, [
+        onChangeTables,
+        getDependents,
+        enqueueCalculation,
+        onChangeSheets,
+        createHistory,
+        onCommand,
+    ]);
+    // Update a table
+    var onUpdateTable = useCallback(function (sheetId, tableId, updatedTable) {
+        updateTable({
+            locale: locale,
+            enqueueCalculation: enqueueCalculation,
+            createHistory: createHistory,
+            onChangeTables: onChangeTables,
+            onChangeSheetData: onChangeSheetData,
+            getFormattedValue: getFormattedValue,
+            getDependents: getDependents,
+            tables: tables,
+            generatedNames: generatedNames,
+        })(sheetId, tableId, updatedTable);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "update-table",
+            sheetId: sheetId,
+            tableId: tableId,
+            updatedTable: updatedTable,
+        });
+    }, [
+        locale,
+        tables,
+        createHistory,
+        getFormattedValue,
+        onChangeTables,
+        onChangeSheetData,
+        enqueueCalculation,
+        getDependents,
+        onCommand,
+        generatedNames,
+    ]);
+    /**
+     * Create a basic filter
+     */
+    var onCreateBasicFilter = useCallback(function (sheetId, activeCell, selections, basicFilterSpec) { return __awaiter(void 0, void 0, void 0, function () {
+        var lastSelection, tableIntersects, saveHistory, range, filterSpecs, sortSpecs, basicFilter, hiddenRows, _a;
+        var _b, _c, _d, _e, _f, _g;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    if (!canPerformSheetAction(sheetId, "autoFilter")) {
+                        showError({
+                            title: SHEET_PROTECTION_ERROR_TITLE,
+                            message: "You can't change filters on a protected sheet.",
+                        });
+                        return [2 /*return*/];
+                    }
+                    lastSelection = selections === null || selections === void 0 ? void 0 : selections[selections.length - 1];
+                    tableIntersects = tables === null || tables === void 0 ? void 0 : tables.find(function (table) {
+                        return areaIntersects(table.range, lastSelection === null || lastSelection === void 0 ? void 0 : lastSelection.range) &&
+                            table.sheetId === sheetId;
+                    });
+                    if (tableIntersects) {
+                        showError({
+                            title: "Error",
+                            message: "You cannot create a filter that spans a table.",
+                        });
+                        return [2 /*return*/];
+                    }
+                    saveHistory = createHistory();
+                    range = lastSelection
+                        ? lastSelection.range
+                        : (_b = getContentfulRangeAroundCell === null || getContentfulRangeAroundCell === void 0 ? void 0 : getContentfulRangeAroundCell(sheetId, activeCell)) !== null && _b !== void 0 ? _b : selectionFromActiveCell(activeCell)[0].range;
+                    filterSpecs = (_d = (_c = basicFilterSpec === null || basicFilterSpec === void 0 ? void 0 : basicFilterSpec.filterSpecs) === null || _c === void 0 ? void 0 : _c.map(function (spec) {
+                        return __assign(__assign({}, spec), { 
+                            // Relative column index as per excel spec
+                            columnIndex: spec.columnIndex - range.startColumnIndex });
+                    })) !== null && _d !== void 0 ? _d : [];
+                    sortSpecs = (_f = (_e = basicFilterSpec === null || basicFilterSpec === void 0 ? void 0 : basicFilterSpec.sortSpecs) === null || _e === void 0 ? void 0 : _e.map(function (spec) {
+                        return __assign(__assign({}, spec), { 
+                            // Relative column index as per excel spec
+                            dimensionIndex: spec.dimensionIndex - range.startColumnIndex });
+                    })) !== null && _f !== void 0 ? _f : [];
+                    basicFilter = __assign(__assign({ id: (_g = idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("table")) !== null && _g !== void 0 ? _g : uuid(), range: range }, basicFilterSpec), { filterSpecs: filterSpecs, sortSpecs: sortSpecs });
+                    if (!basicFilter.filterSpecs) return [3 /*break*/, 2];
+                    return [4 /*yield*/, getHiddenRowsFromFilterSpecs(sheetId, basicFilter, basicFilter.filterSpecs, onRequestCalculate, getEffectiveValue, getFormattedValue, getSheetName, spreadsheetTheme)];
+                case 1:
+                    _a = _h.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    _a = new Set();
+                    _h.label = 3;
+                case 3:
+                    hiddenRows = _a;
+                    // Update sheets
+                    onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+                        var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                            var _a, _b;
+                            var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                            if (sheet) {
+                                var existingFilter = sheet.basicFilter;
+                                // User is creating a new filter
+                                if (existingFilter) {
+                                    // Remove hidden rows
+                                    for (var rowIndex = existingFilter.range.startRowIndex; rowIndex <= existingFilter.range.endRowIndex; rowIndex++) {
+                                        if ((_b = (_a = sheet.rowMetadata) === null || _a === void 0 ? void 0 : _a[rowIndex]) === null || _b === void 0 ? void 0 : _b.hiddenByFilter) {
+                                            sheet.rowMetadata[rowIndex].hiddenByFilter = false;
+                                        }
+                                    }
+                                }
+                                if ((sheet === null || sheet === void 0 ? void 0 : sheet.basicFilter) &&
+                                    (isCellWithinBounds(activeCell, sheet.basicFilter.range) ||
+                                        areaIntersects(sheet.basicFilter.range, lastSelection === null || lastSelection === void 0 ? void 0 : lastSelection.range))) {
+                                    delete sheet.basicFilter;
+                                }
+                                else {
+                                    // Set basic filter
+                                    sheet.basicFilter = basicFilter;
+                                    // Add hidden by filter
+                                    if (hiddenRows.size) {
+                                        if (!sheet.rowMetadata) {
+                                            sheet.rowMetadata = [];
+                                        }
+                                        for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                                            sheet.rowMetadata[rowIndex] = __assign(__assign({}, sheet.rowMetadata[rowIndex]), { hiddenByFilter: hiddenRows.has(rowIndex) ? true : false });
+                                        }
+                                    }
+                                }
+                            }
+                        }), 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: "create-basic-filter",
+                        sheetId: sheetId,
+                        activeCell: activeCell,
+                        selections: selections,
+                        basicFilterSpec: basicFilterSpec,
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [
+        tables,
+        showError,
+        canPerformSheetAction,
+        idCreationStrategy,
+        createHistory,
+        onChangeSheets,
+        getContentfulRangeAroundCell,
+        getEffectiveValue,
+        getFormattedValue,
+        onRequestCalculate,
+        getSheetName,
+        onCommand,
+    ]);
+    /**
+     * Insert table column
+     */
+    var onInsertTableColumn = useCallback(function (tableView, dimensionIndex, direction) {
+        // Validate
+        if (getConfictingTable(tables, tableView)) {
+            showError({
+                message: "You cannot insert or delete cells over part of a table.",
+            });
+            return;
+        }
+        insertTableColumn({
+            tables: tables,
+            columnCount: columnCount,
+            rowCount: rowCount,
+            locale: locale,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: sharedStringRegistry,
+            getSheetName: getSheetName,
+            createHistory: createHistory,
+            onChangeTables: onChangeTables,
+            onChangeSheets: onChangeSheets,
+            onChangeSheetData: onChangeSheetData,
+            enqueueCalculation: enqueueCalculation,
+            enqueueStructureChange: enqueueStructureChange,
+            enqueueGraphOperation: enqueueGraphOperation,
+            getDependents: getDependents,
+            generatedNames: generatedNames,
+        })(tableView, dimensionIndex, direction);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "insert-table-column",
+            tableView: tableView,
+            dimensionIndex: dimensionIndex,
+            direction: direction,
+        });
+    }, [
+        tables,
+        columnCount,
+        rowCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        showError,
+        createHistory,
+        onChangeTables,
+        onChangeSheets,
+        onChangeSheetData,
+        enqueueCalculation,
+        enqueueStructureChange,
+        enqueueGraphOperation,
+        getDependents,
+        getSheetName,
+        onCommand,
+        generatedNames,
+    ]);
+    // Delete a table column
+    var onDeleteTableColumn = useCallback(function (tableView, dimensionIndex) {
+        // Validate - keep React-specific validation at hook level
+        if (getConfictingTable(tables, tableView)) {
+            showError({
+                message: "You cannot insert or delete cells over part of a table.",
+            });
+            return;
+        }
+        deleteTableColumn({
+            columnCount: columnCount,
+            rowCount: rowCount,
+            locale: locale,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: sharedStringRegistry,
+            getSheetName: getSheetName,
+            createHistory: createHistory,
+            onChangeTables: onChangeTables,
+            onChangeSheets: onChangeSheets,
+            onChangeSheetData: onChangeSheetData,
+            enqueueCalculation: enqueueCalculation,
+            enqueueStructureChange: enqueueStructureChange,
+            enqueueGraphOperation: enqueueGraphOperation,
+            getDependents: getDependents,
+        })(tableView, dimensionIndex);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "delete-table-column",
+            tableView: tableView,
+            dimensionIndex: dimensionIndex,
+        });
+    }, [
+        columnCount,
+        rowCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        tables,
+        showError,
+        createHistory,
+        onChangeTables,
+        onChangeSheets,
+        onChangeSheetData,
+        enqueueCalculation,
+        enqueueStructureChange,
+        enqueueGraphOperation,
+        getDependents,
+        getSheetName,
+        onCommand,
+    ]);
+    return {
+        onCreateTable: onCreateTable,
+        onRemoveTable: onRemoveTable,
+        onUpdateTable: onUpdateTable,
+        onCreateBasicFilter: onCreateBasicFilter,
+        onInsertTableColumn: onInsertTableColumn,
+        onDeleteTableColumn: onDeleteTableColumn,
+    };
+};
+export { addTableColumn } from "../interface/table-utils";

package/dist/cjs/hooks/use-on-trace-dependents-precedents.d.ts

@@ -0,0 +1,14 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import React from "react";
+import type { useCalculation } from "./use-calculation";
+export type UseOnTraceDependentsPrecedentsProps = {
+    getPrecedents: ReturnType<typeof useCalculation>["getPrecedents"];
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+};
+export declare const useOnTraceDependentsPrecedents: ({ getDependents, getPrecedents, }: UseOnTraceDependentsPrecedentsProps) => {
+    onRemoveArrows: () => void;
+    onTraceDependents: (sheetId: number, cell: CellInterface) => void;
+    onTracePrecedents: (sheetId: number, cell: CellInterface) => void;
+    arrows: React.ReactNode[];
+};
+//# sourceMappingURL=use-on-trace-dependents-precedents.d.ts.map

package/dist/cjs/hooks/use-on-trace-dependents-precedents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-trace-dependents-precedents.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-trace-dependents-precedents.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAgBhE,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,MAAM,MAAM,mCAAmC,GAAG;IAChD,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;CACnE,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAI,mCAG5C,mCAAmC;;iCAoCtB,MAAM,QAAQ,aAAa;iCAzB3B,MAAM,QAAQ,aAAa;;CAwL1C,CAAC"}

package/dist/cjs/hooks/use-on-trace-dependents-precedents.js

@@ -0,0 +1,146 @@
+import { __assign, __read } from "tslib";
+import { isCellCoordinateWithinCellRange, isCellNode, isCellRangeNode, isStaticNode, } from "@rowsncolumns/dag";
+import { useCallbackRef, useGetCellOffsetFromCoords, } from "@rowsncolumns/spreadsheet";
+import { Arrow } from "@rowsncolumns/ui";
+import { useCallback, useMemo, useState } from "react";
+import React from "react";
+export var useOnTraceDependentsPrecedents = function (_a) {
+    var getDependents = _a.getDependents, getPrecedents = _a.getPrecedents;
+    var getCellOffsetFromCoords = useGetCellOffsetFromCoords();
+    var _b = __read(useState([]), 2), arrowPositions = _b[0], setArrowPosition = _b[1];
+    var onTracePrecedents = useCallbackRef(useCallback(function (sheetId, cell) {
+        var includeSource = true;
+        var precedents = getPrecedents(__assign(__assign({}, cell), { sheetId: sheetId }), includeSource);
+        var pairs = [];
+        precedents.forEach(function (precedent) {
+            if (isStaticNode(precedent)) {
+                return;
+            }
+            precedent.inputKeys.forEach(function (input) {
+                // Skip static-node inputs (chained named ranges). Trace
+                // arrows are a UI feature for grid cells/ranges only.
+                if (isStaticNode(input))
+                    return;
+                pairs.push([input, precedent]);
+            });
+        });
+        setArrowPosition(pairs);
+    }, [getPrecedents] // Add dependency
+    ));
+    var onTraceDependents = useCallbackRef(useCallback(function (sheetId, cell) {
+        var includeSource = true;
+        var dependents = getDependents(__assign(__assign({}, cell), { sheetId: sheetId }), includeSource);
+        var pairs = [];
+        dependents.forEach(function (dependent) {
+            if (isStaticNode(dependent)) {
+                return;
+            }
+            var sourceInput;
+            dependent.inputKeys.forEach(function (input) {
+                if (sourceInput) {
+                    return;
+                }
+                if (isCellNode(input)) {
+                    if (input.position.sheetId === sheetId &&
+                        input.position.rowIndex === cell.rowIndex &&
+                        input.position.columnIndex === cell.columnIndex) {
+                        sourceInput = input;
+                    }
+                }
+                else if (isCellRangeNode(input) &&
+                    isCellCoordinateWithinCellRange({
+                        sheetId: sheetId,
+                        rowIndex: cell.rowIndex,
+                        columnIndex: cell.columnIndex,
+                    }, input)) {
+                    sourceInput = input;
+                }
+            });
+            if (sourceInput) {
+                pairs.push([sourceInput, dependent]);
+            }
+        });
+        setArrowPosition(pairs);
+    }, [getDependents]));
+    var onRemoveArrows = useCallback(function () {
+        setArrowPosition([]);
+    }, []);
+    var arrows = useMemo(function () {
+        return arrowPositions.map(function (pos, index) {
+            var _a = __read(pos, 2), fromNode = _a[0], toNode = _a[1];
+            if (!fromNode || !toNode) {
+                return null;
+            }
+            var startRowIndex = isCellNode(fromNode)
+                ? fromNode.position.rowIndex
+                : fromNode.position.startRowIndex;
+            var startColumnIndex = isCellNode(fromNode)
+                ? fromNode.position.columnIndex
+                : fromNode.position.startColumnIndex;
+            var start = getCellOffsetFromCoords === null || getCellOffsetFromCoords === void 0 ? void 0 : getCellOffsetFromCoords({
+                rowIndex: startRowIndex,
+                columnIndex: startColumnIndex,
+            });
+            var endRowIndex = isCellNode(toNode)
+                ? toNode.position.rowIndex
+                : toNode.position.endRowIndex + 1;
+            var endColumnIndex = isCellNode(toNode)
+                ? toNode.position.columnIndex
+                : toNode.position.endColumnIndex + 1;
+            var end = getCellOffsetFromCoords === null || getCellOffsetFromCoords === void 0 ? void 0 : getCellOffsetFromCoords({
+                rowIndex: endRowIndex,
+                columnIndex: endColumnIndex,
+            });
+            var arrowColor = "#000000";
+            if (start && end) {
+                var x1 = start.x + 20;
+                var y1 = start.y + start.height / 2;
+                var x2 = end.x + 20;
+                var y2 = end.y + end.height / 2;
+                var ranges = [];
+                if (isCellRangeNode(fromNode)) {
+                    var fromRange = fromNode;
+                    var end_1 = getCellOffsetFromCoords === null || getCellOffsetFromCoords === void 0 ? void 0 : getCellOffsetFromCoords({
+                        rowIndex: fromRange.position.endRowIndex + 1,
+                        columnIndex: fromRange.position.endColumnIndex + 1,
+                    });
+                    if (end_1) {
+                        ranges.push(React.createElement("div", { className: "absolute left-0 top-0 border border-solid pointer-events-none", style: {
+                                borderColor: arrowColor,
+                                left: start.x,
+                                top: start.y,
+                                width: end_1.x - start.x,
+                                height: end_1.y - start.y,
+                            } }));
+                    }
+                }
+                if (isCellRangeNode(toNode)) {
+                    var toRange = toNode;
+                    var start_1 = getCellOffsetFromCoords === null || getCellOffsetFromCoords === void 0 ? void 0 : getCellOffsetFromCoords({
+                        rowIndex: toRange.position.startRowIndex,
+                        columnIndex: toRange.position.startColumnIndex,
+                    });
+                    if (start_1) {
+                        ranges.push(React.createElement("div", { className: "absolute left-0 top-0 border border-solid pointer-events-none", style: {
+                                borderColor: arrowColor,
+                                left: start_1.x,
+                                top: start_1.y,
+                                width: end.x - start_1.x,
+                                height: end.y - start_1.y,
+                            } }));
+                    }
+                }
+                return (React.createElement(React.Fragment, null,
+                    ranges,
+                    React.createElement(Arrow, { key: index, x1: x1, x2: x2, y1: y1, y2: y2, showTableIcon: false, color: arrowColor })));
+            }
+            return null;
+        });
+    }, [arrowPositions, getCellOffsetFromCoords]);
+    return {
+        onRemoveArrows: onRemoveArrows,
+        onTraceDependents: onTraceDependents,
+        onTracePrecedents: onTracePrecedents,
+        arrows: arrows,
+    };
+};

package/dist/cjs/hooks/use-on-ungroup-columns.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 UseOnUngroupColumnsProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onCommand?: OnCommand;
+};
+export declare const useOnUngroupColumns: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onCommand, }: UseOnUngroupColumnsProps<T, S>) => (sheetId: number, columnIndexes: number[]) => void;
+//# sourceMappingURL=use-on-ungroup-columns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-ungroup-columns.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-ungroup-columns.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,wBAAwB,CAClC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,KAAK,IACb;IACF,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,mBAAmB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAItE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,eAGnB,MAAM,iBAAiB,MAAM,EAAE,SAsC5C,CAAC"}