@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/use-spreadsheet-state.js

@@ -0,0 +1,2010 @@
+import { isCellNode } from "@rowsncolumns/dag";
+import { isCellWithinBounds } from "@rowsncolumns/grid";
+import { createNewSheet, DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, useGetCellDimensions, useGetColumnWidth, useGetContentfulRangeAroundCell, useGetEffectiveValuesFromRange, useGetRowHeight, } from "@rowsncolumns/spreadsheet";
+import { useFonts } from "@rowsncolumns/spreadsheet";
+import { defaultSpreadsheetTheme, useCallbackRef, useSpreadsheetTheme, } from "@rowsncolumns/spreadsheet";
+import { findMatchingBandProperty, getCurrentLocale, isNil, setDefaultEnableAtFormula, uuid, } from "@rowsncolumns/utils";
+import { enableMapSet, enablePatches, setUseStrictShallowCopy } from "immer";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { getAutoFillValues as defaultGetAutoFillValues } from "../api/fill";
+import { getGeneratedSheetName } from "../generated-names";
+import { SheetCell } from "../sheet-cell";
+import { useCalculation } from "./use-calculation";
+import { useCalculationInitialize } from "./use-calculation-initialize";
+import { useCalculationWorker } from "./use-calculation-worker";
+import { useCellXfsRegistry } from "./use-cellxfs-registry";
+import { useComments } from "./use-comments";
+import { useCitations } from "./use-citations";
+import { useConditionalFormattingRules } from "./use-conditional-formatting-rules";
+import { useDataValidationRules } from "./use-data-validation-rules";
+import { useIndent } from "./use-indent";
+import { useNamedRange } from "./use-named-range";
+import { useOnAutoResize } from "./use-on-autoresize";
+import { useOnBandedRanges } from "./use-on-banded-ranges";
+import { useOnCalculationBegin } from "./use-on-calculation-begin";
+import { useOnCalculationSuccess } from "./use-on-calculation-success";
+import { useOnChange } from "./use-on-change";
+import { useOnChangeBatch } from "./use-on-change-batch";
+import { useOnChangeBatchStream } from "./use-on-change-batch-stream";
+import { useOnChangeDecimals } from "./use-on-change-decimals";
+import { useOnChangeFormatting } from "./use-on-change-formatting";
+import { useOnChangeSheetTabcolor } from "./use-on-change-sheet-tabcolor";
+import { useOnChangeTheme } from "./use-on-change-theme";
+import { useOnClearFormatting } from "./use-on-clear-formatting";
+import { useOnCopy } from "./use-on-copy";
+import { useOnCreateNamedRange } from "./use-on-create-named-range";
+import { useOnCreateNewSheet } from "./use-on-create-sheet";
+import { useOnDelete } from "./use-on-delete";
+import { useOnDeleteCellsShiftLeft } from "./use-on-delete-cells-shift-left";
+import { useOnDeleteCellsShiftUp } from "./use-on-delete-cells-shift-up";
+import { useOnDeleteColumn } from "./use-on-delete-column";
+import { useOnDeleteNamedRange } from "./use-on-delete-named-range";
+import { useOnDeleteRow } from "./use-on-delete-row";
+import { useOnDeleteSheet } from "./use-on-delete-sheet";
+import { useOnDeleteTableRow } from "./use-on-delete-table-row";
+import { useOnDragnDrop } from "./use-on-drag-n-drop";
+import { useOnDuplicateSheet } from "./use-on-duplicate-sheet";
+import { useOnEmbeds } from "./use-on-embeds";
+import { useSlicers } from "./use-slicers";
+import { useOnFill } from "./use-on-fill";
+import { useOnFillRange } from "./use-on-fill-range";
+import { useOnFilterTable } from "./use-on-filter-table";
+import { useOnFindReplace } from "./use-on-find-replace";
+import { useOnFreeze } from "./use-on-freeze";
+import { useOnCollapseColumnGroup } from "./use-on-collapse-column-group";
+import { useOnCollapseRowGroup } from "./use-on-collapse-row-group";
+import { useOnExpandColumnGroup } from "./use-on-expand-column-group";
+import { useOnExpandRowGroup } from "./use-on-expand-row-group";
+import { useOnGroupColumns } from "./use-on-group-columns";
+import { useOnGroupRows } from "./use-on-group-rows";
+import { useOnSetOutlineDepth } from "./use-on-set-outline-depth";
+import { useOnHideColumn } from "./use-on-hide-column";
+import { useOnHideRow } from "./use-on-hide-row";
+import { useOnUngroupColumns } from "./use-on-ungroup-columns";
+import { useOnUngroupRows } from "./use-on-ungroup-rows";
+import { useOnShowHideSheet } from "./use-on-hide-show-sheet";
+import { useOnImportCSV } from "./use-on-import-csv";
+import { useOnImportCSVLegacy } from "./use-on-import-csv-legacy";
+import { useOnImportExcelFile } from "./use-on-import-excel";
+import { useOnInsertAutoSum } from "./use-on-insert-autosum";
+import { useOnInsertCellsShiftDown } from "./use-on-insert-cells-shift-down";
+import { useOnInsertCellsShiftRight } from "./use-on-insert-cells-shift-right";
+import { useOnInsertCheckbox } from "./use-on-insert-checkbox";
+import { useOnInsertColumn } from "./use-on-insert-column";
+import { useOnInsertDate } from "./use-on-insert-date";
+import { useOnInsertDateTime } from "./use-on-insert-date-time";
+import { useOnInsertImage } from "./use-on-insert-image";
+import { useOnInsertLink } from "./use-on-insert-link";
+import { useOnInsertNote } from "./use-on-insert-note";
+import { useOnInsertRow } from "./use-on-insert-row";
+import { useOnInsertTableRow } from "./use-on-insert-table-row";
+import { useOnInsertTime } from "./use-on-insert-time";
+import { useOnMergeUnMergeCells } from "./use-on-merge-unmerge-cells";
+import { useOnMoveColumns } from "./use-on-move-columns";
+import { useOnMoveRows } from "./use-on-move-rows";
+import { useOnMoveSelection } from "./use-on-move-selection";
+import { useOnMoveSheet } from "./use-on-move-sheet";
+import { useOnPaste } from "./use-on-paste";
+import { useOnProtectRange } from "./use-on-protect-range";
+import { useOnProtectSheet } from "./use-on-protect-sheet";
+import { useOnRenameSheet } from "./use-on-rename-sheet";
+import { useOnRequestCalculateWrapper } from "./use-on-request-calculate-wrapper";
+import { useOnRequestConditionalFormat } from "./use-on-request-conditional-format";
+import { useOnRequestDataValidation } from "./use-on-request-data-validation";
+import { useOnRequestDefineNamedRange } from "./use-on-request-define-named-range";
+import { useOnRequestDeleteSheet } from "./use-on-request-delete-sheet";
+import { useOnRequestEditTable } from "./use-on-request-edit-table";
+import { useOnRequestFormatCells } from "./use-on-request-format-cells";
+import { useOnRequestInsertImage } from "./use-on-request-insert-image";
+import { useOnRequestInsertLink } from "./use-on-request-insert-link";
+import { useOnRequestResize } from "./use-on-request-resize";
+import { useOnRequestUpdateNamedRange } from "./use-on-request-update-named-range";
+import { useOnResize } from "./use-on-resize";
+import { useOnResizeTable } from "./use-on-resize-table";
+import { useOnShowColumn } from "./use-on-show-column";
+import { useOnShowRow } from "./use-on-show-row";
+import { useOnSortColumn } from "./use-on-sort-column";
+import { useOnSortRange } from "./use-on-sort-range";
+import { useOnSortTable } from "./use-on-sort-table";
+import { useOnTable } from "./use-on-table";
+import { useOnTraceDependentsPrecedents } from "./use-on-trace-dependents-precedents";
+import { useOnUpdateNamedRange } from "./use-on-update-named-range";
+import { useOnUpdateNote } from "./use-on-update-note";
+import { useOnUpdateSheet } from "./use-on-update-sheet";
+import { usePaintFormat } from "./use-paint-format";
+import { useSelectNextPrevSheet } from "./use-select-next-prev-sheet";
+import { useSheetObserver } from "./use-sheet-observer";
+import { useSheetProperties } from "./use-sheet-properties";
+import { useSheetState } from "./use-sheet-state";
+import { useSheetDataSubscriber } from "./use-sheetdata-subscriber";
+import { useSplitTextToColumns } from "./use-split-text-to-columns";
+import { useOnLocaleChange } from "./use-on-locale-change";
+import { useOnRemoveDuplicates } from "./use-on-remove-duplicates";
+import { useSharedStringRegistry } from "./use-ss-registry";
+import { useStructuredReference } from "./use-structured-reference";
+import { useUndoRedo } from "./use-undo-redo";
+import { useUndoRedoActions } from "./use-undo-redo-actions";
+// Immer
+enablePatches();
+enableMapSet();
+setUseStrictShallowCopy(true);
+// Formulas whose result depends on row visibility (hidden / filtered
+// rows) and therefore must recalc when visibility changes even though
+// no cell value changed.
+const SUBTOTAL_FORMULA_PATTERN = /SUBTOTAL\s*\(/i;
+/**
+ * Banding for a table whose bandedRange was never materialised. Documents imported
+ * before the importers resolved built-in table style names persist only the theme
+ * name (e.g. "TableStyleMedium2"). Mirrors the importers' resolution: the built-in
+ * palette plus the stripe-toggle trim — row stripes off keeps only the header/total
+ * -row visuals, column stripes off drops the column banding.
+ */
+export const deriveBuiltInTableBanding = (table) => {
+    if (!table.theme) {
+        return undefined;
+    }
+    const showRowStripes = table.showRowStripes !== false;
+    const showColumnStripes = table.showColumnStripes === true;
+    const banded = findMatchingBandProperty(table.theme, showRowStripes, showColumnStripes);
+    if (!banded) {
+        return undefined;
+    }
+    if (!showRowStripes && banded.rowProperties) {
+        const { headerColor, headerBorder, totalRowColor, totalRowBorder } = banded.rowProperties;
+        if (headerColor || headerBorder || totalRowColor || totalRowBorder) {
+            banded.rowProperties = {
+                headerColor,
+                headerBorder,
+                totalRowColor,
+                totalRowBorder,
+            };
+        }
+        else {
+            banded.rowProperties = undefined;
+        }
+    }
+    if (!showColumnStripes) {
+        banded.columnProperties = undefined;
+    }
+    if (!banded.rowProperties && !banded.columnProperties) {
+        return undefined;
+    }
+    return banded;
+};
+/**
+ * Use Spreadsheet Hook
+ * @param param0
+ * @returns
+ */
+export const useSpreadsheetState = ({ 
+// Sheets
+sheets, onChangeSheets, 
+// Theme
+theme = defaultSpreadsheetTheme, 
+// Functions
+functions, 
+// OnDemand formula pattern
+onDemandFormulaPattern, enableLazyCalculation = true, 
+// Conditional formats
+conditionalFormats, 
+// Data validations
+dataValidations, 
+// Tables
+tables, namedRanges, 
+// Flag for excel import history change
+enableExcelImportHistory, enableExcelfileDragDrop, onChangeTables, onChangeNamedRanges, onChangeCharts, onChangeEmbeds, onChangeProtectedRanges, onChangeConditionalFormats, onChangeDataValidations, onChangeBandedRanges, onChangePivotTables, 
+// Grid data
+sheetData, onChangeSheetData, 
+// Calculator
+onChangeDependencyGraph, 
+// History
+onChangeHistory, 
+// Semantic command stream
+onCommand: onCommandProp, 
+// Theme
+onChangeTheme, 
+// error handler
+onError, 
+// Get auto fill values
+getAutoFillValues: rawGetAutoFillValues = defaultGetAutoFillValues, 
+// User-defined autofill lists
+customAutofillLists, 
+// For calculations
+getEffectiveStructuredValue, 
+// Dark theme classname
+darkThemeClassName = "rnc-dark", 
+// Color mode
+colorMode, 
+// Google fonts that will be loaded
+// on-demand
+fonts, 
+// Drag and drop
+enableDragnDrop = true, 
+// Enable undo/redo functionality
+enabledUndoRedo = true, 
+// Current locale
+locale = getCurrentLocale(), 
+// Templates for auto-generated names (sheets, tables, table columns)
+generatedNames: generatedNamesProp, enableAtFormula = false, 
+// Preserve data formatting like color, font style on paste
+preserveFormattingOnPaste, 
+// Trigger manual recalculation
+recalculateOnOpen = false, 
+// Protect formulas
+protectFormulas, 
+// Max limits
+maxRowCount, maxColumnCount, maxSheetCount, 
+// ID Creation strategy
+idCreationStrategy, 
+// File size limit
+fileSizeLimit, 
+// Hydrated registry passed in by user
+cellXfs, cellStyles, onChangeCellXfs, 
+// Shared strings
+sharedStrings, onChangeSharedStrings, 
+// Callback when new fonts are requested
+onRequestFonts, 
+// Slicers
+onChangeSlicers, 
+// Citations
+citations, onChangeCitations, 
+// Create calculation worker
+createCalculationWorker, 
+// Calculation mode
+calculationMode = "single", iterativeCalculation, onIterativeCalculationEnabled, 
+// Stream callbacks
+onStreamStart, onStreamProgress, onStreamEnd, 
+// Custom modal functions
+onConfirm, onPrompt, 
+/**
+ * Optional HTML sanitizer for clipboard paste operations.
+ * Called before parsing HTML from clipboard to prevent XSS attacks.
+ * Use with DOMPurify or similar library.
+ */
+sanitizeHtml, }) => {
+    /**
+     * Sheets
+     */
+    const { activeSheetId, activeCell, selections, activeCellBySheetId, selectionsBySheetId, onChangeActiveCell, onChangeActiveSheet, onChangeSelections, } = useSheetState({
+        sheets,
+        onChangeSheets,
+    });
+    // Load default fonts
+    useFonts(fonts);
+    // Disable @ formula
+    useEffect(() => {
+        SheetCell.setDefaultEnableAtFormula(enableAtFormula);
+        setDefaultEnableAtFormula(enableAtFormula);
+    }, [enableAtFormula]);
+    // Auto resize
+    const getFinalColumnWidth = useGetColumnWidth();
+    const getFinalRowHeight = useGetRowHeight();
+    const sharedStringRegistry = useSharedStringRegistry(sharedStrings ?? undefined, onChangeSharedStrings);
+    // CellXfs CellFormat registry
+    const cellXfsRegistry = useCellXfsRegistry(cellXfs, onChangeCellXfs);
+    // Themes
+    const { isDarkMode, ...spreadsheetColors } = useSpreadsheetTheme({
+        theme,
+        darkThemeClassName,
+        colorMode,
+    });
+    // Consumers commonly pass an inline `onCommand` (a fresh function every
+    // render). Roughly 40 derived callbacks list `onCommand` in their
+    // `useCallback` deps (onSplitTextToColumns, onChangeFormatting, onPaste, …),
+    // so an unstable emitter gives every one of them a new identity each render —
+    // which cascades into a CanvasGrid re-render loop ("Maximum update depth
+    // exceeded"). Stabilize the identity via `useCallbackRef`, but preserve
+    // undefined-ness so the `if (onCommand)` presence checks in those hooks still
+    // short-circuit when no emitter was supplied.
+    const onCommandStable = useCallbackRef(onCommandProp);
+    const onCommand = onCommandProp ? onCommandStable : undefined;
+    // Consumers commonly pass `generatedNames` as an inline object literal with
+    // inline arrow functions (fresh identities every render). Stabilize it the
+    // same way as `onCommand` above: constant-identity wrappers that always
+    // delegate to the latest formatters, so the `useCallback`s that list
+    // `generatedNames` in their deps never see a new identity. Preserve
+    // undefined-ness so the default (no prop) stays a stable no-op.
+    const generatedNameSheet = useCallbackRef(generatedNamesProp?.sheet);
+    const generatedNameSheetCopy = useCallbackRef(generatedNamesProp?.sheetCopy);
+    const generatedNameTable = useCallbackRef(generatedNamesProp?.table);
+    const generatedNameTableCopy = useCallbackRef(generatedNamesProp?.tableCopy);
+    const generatedNameTableColumn = useCallbackRef(generatedNamesProp?.tableColumn);
+    const generatedNamesStable = useMemo(() => ({
+        sheet: generatedNameSheet,
+        sheetCopy: generatedNameSheetCopy,
+        table: generatedNameTable,
+        tableCopy: generatedNameTableCopy,
+        tableColumn: generatedNameTableColumn,
+    }), [
+        generatedNameSheet,
+        generatedNameSheetCopy,
+        generatedNameTable,
+        generatedNameTableCopy,
+        generatedNameTableColumn,
+    ]);
+    const generatedNames = generatedNamesProp ? generatedNamesStable : undefined;
+    // Get current active cell
+    const getActiveCell = useCallbackRef(useCallback(() => activeCell, [activeCell]));
+    // Get current active cell
+    const getSelections = useCallbackRef(useCallback(() => selections, [selections]));
+    // Extract row count and column count
+    const { rowCount: _rowCount = DEFAULT_ROW_COUNT, columnCount: _columnCount = DEFAULT_COLUMN_COUNT, frozenColumnCount, frozenRowCount, rowMetadata, columnMetadata, merges, showGridLines, showRowColHeaders, zoomScale, basicFilter, } = useMemo(() => {
+        const sheet = sheets.find((sheet) => sheet.sheetId === activeSheetId);
+        // For collaboration mode
+        // when someone deletes a sheet
+        if (!sheet) {
+            const sheetLen = sheets.length;
+            return createNewSheet(idCreationStrategy?.("sheet") ?? uuid(), getGeneratedSheetName(sheetLen + 1, generatedNames), maxRowCount, maxColumnCount, false);
+        }
+        return sheet;
+    }, [
+        activeSheetId,
+        idCreationStrategy,
+        sheets,
+        maxRowCount,
+        maxColumnCount,
+        generatedNames,
+    ]);
+    // Accept defaults
+    const rowCount = _rowCount ?? DEFAULT_ROW_COUNT;
+    const columnCount = _columnCount ?? DEFAULT_ROW_COUNT;
+    // Check if cell is merged
+    const isMergedCell = useCallback((sheetId, rowIndex, columnIndex) => {
+        const sheet = sheets.find((sheet) => sheet.sheetId === sheetId);
+        if (sheet) {
+            return sheet.merges?.some((range) => {
+                return isCellWithinBounds({ rowIndex, columnIndex }, range);
+            });
+        }
+        return false;
+    }, [sheets]);
+    /**
+     * Get banded ranges from table. A table with no materialised bandedRange falls back
+     * to its built-in theme name — documents imported before the importers resolved
+     * built-in table styles persist only the name, and the grid paints tables
+     * exclusively from bandedRange, so without the fallback they render unstyled.
+     */
+    const bandedRanges = useMemo(() => {
+        return tables
+            ?.filter(({ sheetId }) => sheetId === activeSheetId)
+            .map((table) => {
+            const banded = table.bandedRange ??
+                deriveBuiltInTableBanding(table);
+            if (isNil(banded)) {
+                return undefined;
+            }
+            return {
+                bandedRangeId: `${table.id}-${table.theme}`,
+                // Add sheet Id to range
+                range: {
+                    ...table.range,
+                    sheetId: activeSheetId,
+                },
+                ...banded,
+            };
+        })
+            .filter((band) => !isNil(band));
+    }, [tables, activeSheetId]);
+    const getCellDimensions = useGetCellDimensions();
+    const getCurrentRowHeight = useGetRowHeight();
+    const getContentfulRangeAroundCell = useGetContentfulRangeAroundCell();
+    /**
+     * Forward-reference for `getPrecedents` so `useSheetProperties` can call
+     * it from inside `getEffectiveFormat` without depending on hook order
+     * (the calculator hook initialises after sheet-properties).
+     */
+    const getPrecedentsRef = useRef(undefined);
+    const getPrecedentsForward = useCallback((cell) => getPrecedentsRef.current?.(cell) ?? [], []);
+    // Sheet properties
+    const { getDataRowCount, getNonEmptyRowCount, getNonEmptyColumnCount, getDataColumnCount, getSheetId, getSheetName, getSheetCount, getSheetIndex, getSheetProperties, getCellData, getMentionsFromCell, getTextFormatRuns, getEffectiveValue, getEffectiveValueForCalculation, getUserEnteredValue, getUserEnteredValueStable, getConditionalFormatFormula, getDataValidationFormula, getDataValidation, getDataValidationById, getActiveSheetId, getUserEnteredFormat, getEffectiveFormat, getFormattedValue, getSeriesValuesFromRange, getFormattingFromRange, getUserEnteredValuesFromRange, getFormulasFromRange, getDomainValuesFromRange, getColumnarDataFromRange, isColumnHidden, isHiddenRow, isHiddenByFilterRow, getSheetRowCount, getSheetColumnCount, getColumnWidth, getRowHeight, getEffectiveExtendedValue, getUserEnteredExtendedValue, getFrozenRowCount, getErrorValue, } = useSheetProperties({
+        getEffectiveStructuredValue,
+        conditionalFormats,
+        sheetData,
+        sheets,
+        activeSheetId,
+        cellXfs,
+        cellXfsRegistry,
+        cellStyles: cellStyles ?? undefined,
+        protectFormulas,
+        dataValidations,
+        sharedStrings,
+        locale,
+        getPrecedents: getPrecedentsForward,
+    });
+    // Subscriber
+    useSheetDataSubscriber({ sheetData });
+    const { onSelectNextSheet, onSelectPreviousSheet } = useSelectNextPrevSheet({
+        onChangeActiveSheet,
+        sheets,
+    });
+    // Get structured reference
+    const onStructuredReference = useStructuredReference({
+        tables,
+        sheetId: activeSheetId,
+        getSheetName,
+    });
+    // Named ranges
+    const onNamedRange = useNamedRange({
+        namedRanges,
+        getSheetName,
+    });
+    // calculation success
+    const onCalculationSuccess = useOnCalculationSuccess({
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDataValidationById,
+        onChangeSheetData,
+        getPrecedents(source) {
+            return getPrecedents(source);
+        },
+        createHistory() {
+            return createHistoryWithoutPointer();
+        },
+        getSheetId,
+    });
+    // Being calculation
+    const onCalculationBegin = useOnCalculationBegin({
+        onChangeSheetData,
+        locale,
+        cellXfsRegistry,
+    });
+    // Sheet mneta data for worker
+    const sheetsMetadata = useMemo(() => sheets.map((sheet) => {
+        return {
+            id: sheet.sheetId,
+            name: sheet.title,
+            rowCount: sheet.rowCount ?? undefined,
+            columnCount: sheet.columnCount ?? undefined,
+        };
+    }), [sheets]);
+    // Worker-based calculation hook
+    const workerCalculation = useCalculationWorker({
+        locale,
+        sheets: sheetsMetadata,
+        tables,
+        namedRanges,
+        createWorker: createCalculationWorker,
+        getActiveSheetId,
+        activeSheetId,
+        onSuccess: onCalculationSuccess,
+        onBeginCalculation: onCalculationBegin,
+        getSheetName,
+        getSheetCount,
+        getSheetIndex,
+        onStructuredReference,
+        getSheetId,
+        onNamedRange,
+        getSheetProperties,
+        getEffectiveValue: getEffectiveValueForCalculation,
+        getUserEnteredValue: getUserEnteredValueStable,
+        getConditionalFormatFormula,
+        getDataValidationFormula,
+        onDemandFormulaPattern,
+        enableLazyCalculation,
+        onChangeStaticReference: (nodes) => onChangeStaticReference(nodes),
+        onChangeDependencyGraph,
+        iterativeCalculation,
+        // Not implemented yet in worker level..
+        // Worker has no access to underlying cell data in the sheet
+        getCellData,
+        getEffectiveStructuredValue,
+        enabled: calculationMode === "worker",
+    });
+    // Single-threaded calculation hook
+    const singleCalculation = useCalculation({
+        locale,
+        getActiveSheetId,
+        onSuccess: onCalculationSuccess,
+        onBeginCalculation: onCalculationBegin,
+        getSheetName,
+        getSheetCount,
+        onStructuredReference,
+        getSheetId,
+        onNamedRange,
+        namedRanges,
+        getSheetProperties,
+        getEffectiveValue: getEffectiveValueForCalculation,
+        activeSheetId,
+        getSheetIndex,
+        getUserEnteredValue: getUserEnteredValueStable,
+        getConditionalFormatFormula,
+        getDataValidationFormula,
+        functions,
+        onDemandFormulaPattern,
+        enableLazyCalculation,
+        onChangeStaticReference: (nodes) => onChangeStaticReference(nodes),
+        onChangeDependencyGraph,
+        getCellData,
+        getEffectiveStructuredValue,
+        iterativeCalculation,
+        isRowHidden: isHiddenRow,
+        isRowHiddenByFilter: isHiddenByFilterRow,
+        enabled: calculationMode !== "worker",
+    });
+    // Use the appropriate calculation hook based on mode
+    const { enqueueCalculation, enqueueGraphOperation, enqueueStructureChange, clearRangeCache, onRequestCalculate: onRequestCalculateWithoutFormatting, getPrecedents, getDependents, getPrecedentsFromFormulaString, getGraphNodes, getGraphNodesInSheet, addStaticReference, addFormulaToGraph, removeStaticReference, onResetCalculator, getDependencyGraph, updateDependencyGraph, isArrayFormula, applyNamedRanges, } = calculationMode === "worker" ? workerCalculation : singleCalculation;
+    // Bind the forward-ref so `useSheetProperties.getEffectiveFormat` can walk
+    // precedents now that the calculator is initialised.
+    getPrecedentsRef.current = getPrecedents;
+    /**
+     * Row visibility changed (filter applied/cleared, rows hidden or
+     * unhidden). Cell values are untouched so the dependency graph has
+     * nothing dirty — but SUBTOTAL reads row visibility, so re-run every
+     * SUBTOTAL formula in the workbook.
+     */
+    const onRowVisibilityChange = useCallback(() => {
+        for (const node of getGraphNodes().values()) {
+            if (!isCellNode(node)) {
+                continue;
+            }
+            const { position } = node;
+            const userEnteredValue = getUserEnteredValueStable(position.sheetId, position.rowIndex, position.columnIndex);
+            if (typeof userEnteredValue === "string" &&
+                SUBTOTAL_FORMULA_PATTERN.test(userEnteredValue)) {
+                enqueueCalculation({ type: "dirty", position, force: true });
+            }
+        }
+    }, [getGraphNodes, enqueueCalculation, getUserEnteredValueStable]);
+    // Sheet data observer
+    const { onChangeStaticReference } = useSheetObserver({
+        onAddStaticReference: addStaticReference,
+        onRemoveStaticReference: removeStaticReference,
+    });
+    // Intercept request calculate to inject formatting
+    const onRequestCalculate = useOnRequestCalculateWrapper({
+        locale,
+        sheetData,
+        getPrecedentsFromFormulaString,
+        getSheetId,
+        cellXfsRegistry,
+        onRequestCalculate: onRequestCalculateWithoutFormatting,
+        getEffectiveFormat,
+    });
+    // Calculation initialize
+    const { calculateNow, evaluateConditionalFormatting, evaluateDataValidations, evaluateConditionalFormattingForViewport, evaluateDataValidationsForViewport, clearEvaluatedCellsCache, onViewPortChange, reevaluateDerivationsForCells, } = useCalculationInitialize({
+        recalculateOnOpen,
+        sheetData,
+        conditionalFormats,
+        dataValidations,
+        activeSheetId,
+        iterativeCalculation,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        onResetCalculator,
+        getDataValidationById,
+        namedRanges,
+        applyNamedRanges,
+    });
+    // Undo redo action manager
+    const { onRedoAction, onUndoAction, applyPatch } = useUndoRedoActions({
+        sheetId: activeSheetId,
+        onChangeActiveCell,
+        onChangeActiveSheet,
+        onChangeSelections,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeCharts,
+        onChangeEmbeds,
+        onChangeTables,
+        onChangeNamedRanges,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onChangeProtectedRanges,
+        onChangePivotTables,
+        onChangeCellXfs,
+        onChangeTheme,
+        onChangeSlicers,
+        onChangeCitations,
+        enqueueCalculation,
+        onChangeSharedStrings,
+        clearRangeCache,
+    });
+    // Undo manager
+    const { createHistory, createHistoryWithoutPointer, onRedo, onUndo, canUndo, canRedo, onClearHistory, } = useUndoRedo({
+        isEnabled: enabledUndoRedo,
+        onUndoAction,
+        onRedoAction,
+        onChangeHistory,
+    });
+    const onChangeSpreadsheetTheme = useOnChangeTheme({
+        createHistory,
+        onChangeTheme,
+        onCommand,
+    });
+    // Sheet color
+    const onChangeSheetTabColor = useOnChangeSheetTabcolor({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    // Sheet name
+    const onRenameSheet = useOnRenameSheet({
+        locale,
+        createHistory,
+        onChangeSheets,
+        onChangeSheetData,
+        onChangeActiveCell,
+        getActiveCell,
+        getGraphNodes,
+        getPrecedents,
+        onCommand,
+    });
+    // Confirm delete sheet
+    const onRequestDeleteSheet = useOnRequestDeleteSheet();
+    // Sheet delete
+    const onDeleteSheet = useOnDeleteSheet({
+        sheets,
+        createHistory,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeActiveSheet,
+        enqueueGraphOperation,
+        onCommand,
+    });
+    // Show hide sheet
+    const { onHideSheet, onShowSheet } = useOnShowHideSheet({
+        sheetId: activeSheetId,
+        sheets,
+        onChangeSheets,
+        createHistory,
+        onChangeActiveSheet,
+        onCommand,
+    });
+    // Protect sheet
+    const { onProtectSheet, onUnProtectSheet } = useOnProtectSheet({
+        idCreationStrategy,
+        onChangeProtectedRanges,
+        createHistory,
+        onCommand,
+    });
+    // Move sheet
+    const onMoveSheet = useOnMoveSheet({
+        onChangeSheets,
+        createHistory,
+        onCommand,
+    });
+    // New sheet
+    const onCreateNewSheet = useOnCreateNewSheet({
+        sheets,
+        maxRowCount,
+        maxColumnCount,
+        idCreationStrategy,
+        createHistory,
+        onChangeActiveSheet,
+        onChangeSheets,
+        maxSheetCount,
+        sheetId: activeSheetId,
+        onCommand,
+        generatedNames,
+    });
+    // Update sheet
+    const onUpdateSheet = useOnUpdateSheet({
+        sheets,
+        onChangeSheets,
+        createHistory,
+    });
+    // Request add rows
+    const onRequestAddRows = useCallback((sheetId, additionalRowCount) => {
+        return onUpdateSheet?.(sheetId, {
+            rowCount: (rowCount ?? DEFAULT_ROW_COUNT) + additionalRowCount,
+        });
+    }, [rowCount, onUpdateSheet]);
+    // Duplicate sheet
+    const onDuplicateSheet = useOnDuplicateSheet({
+        locale,
+        maxSheetCount,
+        sheets,
+        idCreationStrategy,
+        createHistory,
+        enqueueGraphOperation,
+        onChangeActiveSheet,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        onChangeCharts,
+        onChangeEmbeds,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onCommand,
+        generatedNames,
+    });
+    // Hide column
+    const onHideColumn = useOnHideColumn({
+        rowCount,
+        columnCount,
+        getSelections,
+        getActiveCell,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheets,
+        createHistory,
+        onCommand,
+    });
+    // Show column
+    const onShowColumn = useOnShowColumn({
+        rowCount,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheets,
+        createHistory,
+        onCommand,
+    });
+    // Hide row
+    const onHideRow = useOnHideRow({
+        columnCount,
+        rowCount,
+        getSelections,
+        getActiveCell,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheets,
+        createHistory,
+        onCommand,
+        onRowVisibilityChange,
+    });
+    // Show row
+    const onShowRow = useOnShowRow({
+        columnCount,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheets,
+        createHistory,
+        onCommand,
+        onRowVisibilityChange,
+    });
+    // Outline (row/column grouping) handlers. All eight share the same
+    // shape: take a sheetId + the relevant indices, mutate metadata via
+    // immer with history saved.
+    const onGroupRows = useOnGroupRows({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    const onUngroupRows = useOnUngroupRows({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    const onCollapseRowGroup = useOnCollapseRowGroup({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    const onExpandRowGroup = useOnExpandRowGroup({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    const onGroupColumns = useOnGroupColumns({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    const onUngroupColumns = useOnUngroupColumns({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    const onCollapseColumnGroup = useOnCollapseColumnGroup({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    const onExpandColumnGroup = useOnExpandColumnGroup({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    const onSetOutlineDepth = useOnSetOutlineDepth({
+        createHistory,
+        onChangeSheets,
+        onCommand,
+    });
+    // onChange handler
+    const onChange = useOnChange({
+        tables,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDataValidationById,
+        isMergedCell,
+        onChangeSheetData,
+        onChangeTables,
+        onChangeSheets,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        createHistory,
+        getDependents,
+        getUserEnteredValue: getUserEnteredValueStable,
+        getTextFormatRuns,
+        getSheetName,
+        onCommand,
+        generatedNames,
+    });
+    // onChange batch
+    const onChangeBatch = useOnChangeBatch({
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDataValidationById,
+        getUserEnteredValue: getUserEnteredValueStable,
+        getDependents,
+        enqueueGraphOperation,
+        getSheetName,
+        enqueueCalculation,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        getFormattedValue,
+        getCellDimensions,
+        getRowHeight: getCurrentRowHeight,
+        isMergedCell,
+        tables,
+        createHistory,
+        onChangeCitations,
+        onCommand,
+        generatedNames,
+    });
+    // onChange handler
+    const onDelete = useOnDelete({
+        locale,
+        rowCount,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDataValidationById,
+        getDependents,
+        getDataRowCount,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        onChangeCitations,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeActiveCell,
+        isArrayFormula,
+        getRowHeight: getCurrentRowHeight,
+        onCommand,
+    });
+    // Formatting change
+    const { onChangeFormatting, onChangeBorder, onRepeatFormatting } = useOnChangeFormatting({
+        locale,
+        cellXfsRegistry,
+        getDataValidationById,
+        isMergedCell,
+        onChangeSheetData,
+        onChangeSheets,
+        createHistory,
+        getFormattedValue,
+        enqueueCalculation,
+        getCellDimensions,
+        getRowHeight: getCurrentRowHeight,
+        onCommand,
+    });
+    // Paint formatting
+    const { isPaintFormatActive, paintFormat, onApplyPaintFormat, onSavePaintFormat, } = usePaintFormat({
+        onChangeSelections,
+        onChangeFormatting,
+        getEffectiveFormat,
+    });
+    // Selection interceptor
+    // for paint format
+    const onChangeSelectionsInterceptor = useCallback((sheetId, selections, finishedSelection) => {
+        if (isPaintFormatActive && finishedSelection) {
+            onApplyPaintFormat(sheetId, activeCell, selections);
+        }
+        else {
+            onChangeSelections(sheetId, selections);
+        }
+    }, [isPaintFormatActive, activeCell, onApplyPaintFormat, onChangeSelections]);
+    // Formatting clear
+    const onClearFormatting = useOnClearFormatting({
+        locale,
+        cellXfsRegistry,
+        getDataValidationById,
+        onChangeSheetData,
+        createHistory,
+        onCommand,
+    });
+    // Locale change - regenerate formatted values and normalize validation rules
+    const onChangeLocale = useOnLocaleChange({
+        cellXfsRegistry,
+        sharedStringRegistry,
+        onChangeSheetData,
+        createHistory: createHistoryWithoutPointer,
+        dataValidations,
+        onChangeDataValidations,
+        conditionalFormats,
+        onChangeConditionalFormats,
+    });
+    // Merge unmerge
+    const { onMergeCells, onUnMergeCells } = useOnMergeUnMergeCells({
+        locale,
+        merges,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        onChangeSelections,
+        createHistory,
+        onChangeSheets,
+        onChangeSheetData,
+        enqueueCalculation,
+        onCommand,
+    });
+    // Resize
+    const onResize = useOnResize({
+        onChangeSheets,
+        createHistory,
+        getActiveCell,
+        getCellDimensions,
+        getRowHeight: getFinalRowHeight,
+        isMergedCell,
+        onCommand,
+    });
+    // Decimals
+    // Formatting change
+    const onChangeDecimals = useOnChangeDecimals({
+        locale,
+        cellXfsRegistry,
+        getDataValidationById,
+        onChangeSheetData,
+        createHistory,
+        enqueueCalculation,
+        onCommand,
+    });
+    // Wrap user-supplied or default getAutoFillValues so it always sees
+    // the host-supplied customAutofillLists, without making consumers
+    // remember to thread the param themselves.
+    const getAutoFillValues = useCallback((props) => rawGetAutoFillValues({
+        ...props,
+        customAutofillLists: props.customAutofillLists ?? customAutofillLists,
+    }), [rawGetAutoFillValues, customAutofillLists]);
+    // Fill
+    const onFill = useOnFill({
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDataValidationById,
+        getCellData,
+        getAutoFillValues,
+        getEffectiveValue,
+        getFormattedValue,
+        getSheetName,
+        enqueueCalculation,
+        enqueueStructureChange,
+        onChangeSheetData,
+        onChangeDataValidations,
+        createHistory,
+        onCommand,
+    });
+    // Delete row
+    const onDeleteRow = useOnDeleteRow({
+        rowCount,
+        columnCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getActiveCell,
+        getSelections,
+        getDependents,
+        getGraphNodes,
+        getGraphNodesInSheet,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeTables,
+        onChangeSheetData,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onChangeCitations,
+        onChangePivotTables,
+        getSheetName,
+        onCommand,
+    });
+    // Delete row
+    const onDeleteColumn = useOnDeleteColumn({
+        rowCount,
+        columnCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getSelections,
+        getActiveCell,
+        getDependents,
+        getGraphNodes,
+        getGraphNodesInSheet,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeTables,
+        onChangeSheetData,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onChangeCitations,
+        onChangePivotTables,
+        getSheetName,
+        onCommand,
+    });
+    // Delete cells shift up
+    const onDeleteCellsShiftUp = useOnDeleteCellsShiftUp({
+        rowCount,
+        columnCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getActiveCell,
+        getSelections,
+        getDependents,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeSheetData,
+        onCommand,
+    });
+    // Delete cells shift left
+    const onDeleteCellsShiftLeft = useOnDeleteCellsShiftLeft({
+        rowCount,
+        columnCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getActiveCell,
+        getSelections,
+        getDependents,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeSheetData,
+        onCommand,
+    });
+    // Insert cells shift right
+    const onInsertCellsShiftRight = useOnInsertCellsShiftRight({
+        rowCount,
+        columnCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getActiveCell,
+        getSelections,
+        getDependents,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeSheetData,
+        onCommand,
+    });
+    // Delete cells shift up
+    const onInsertCellsShiftDown = useOnInsertCellsShiftDown({
+        rowCount,
+        columnCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getActiveCell,
+        getSelections,
+        getDependents,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeSheetData,
+        onCommand,
+    });
+    // Insert row
+    const onInsertRow = useOnInsertRow({
+        rowCount,
+        columnCount,
+        locale,
+        maxRowCount,
+        cellXfsRegistry,
+        getActiveCell,
+        getSelections,
+        getDependents,
+        getGraphNodes,
+        getGraphNodesInSheet,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeSheetData,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onChangeCitations,
+        onChangePivotTables,
+        onChangeTables,
+        getSheetName,
+        onCommand,
+    });
+    // Insert column
+    const onInsertColumn = useOnInsertColumn({
+        rowCount,
+        columnCount,
+        locale,
+        tables,
+        maxColumnCount,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDependents,
+        getGraphNodes,
+        getGraphNodesInSheet,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeTables,
+        onChangeSheetData,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onChangeCitations,
+        onChangePivotTables,
+        getActiveCell,
+        getSelections,
+        getSheetName,
+        onCommand,
+        generatedNames,
+    });
+    // Move columns
+    const onMoveColumns = useOnMoveColumns({
+        rowCount,
+        columnCount,
+        locale,
+        getActiveCell,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeTables,
+        onChangeSheetData,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        getDependents,
+        getDataRowCount,
+        onCommand,
+    });
+    // Move rows
+    const onMoveRows = useOnMoveRows({
+        rowCount,
+        columnCount,
+        locale,
+        getActiveCell,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheets,
+        onChangeSheetData,
+        onChangeTables,
+        onChangeNamedRanges,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        getDependents,
+        getNonEmptyColumnCount,
+        onCommand,
+    });
+    // Move selection
+    const onMoveSelection = useOnMoveSelection({
+        rowCount,
+        columnCount,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        createHistory,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        onChangeNamedRanges,
+        onChangeDataValidations,
+        onChangeConditionalFormats,
+        onChangePivotTables,
+        getDependents,
+        getActiveCell,
+        isArrayFormula,
+        tables,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        onCommand,
+    });
+    // Sort column
+    const onSortColumn = useOnSortColumn({
+        rowCount,
+        columnCount,
+        locale,
+        sharedStringRegistry,
+        onChangeSheetData,
+        enqueueCalculation,
+        enqueueStructureChange,
+        enqueueGraphOperation,
+        createHistory,
+        isHiddenRow,
+        getDependents,
+        getFrozenRowCount,
+        getSheetName,
+        getEffectiveFormat,
+        theme,
+        onCommand,
+    });
+    // Sort range
+    const onSortTable = useOnSortTable({
+        locale,
+        sharedStringRegistry,
+        onChangeSheetData,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        getDependents,
+        createHistory,
+        onChangeTables,
+        onChangeSheets,
+        getActiveCell,
+        isHiddenRow,
+        getFrozenRowCount,
+        getSheetName,
+        getEffectiveFormat,
+        theme,
+        onCommand,
+    });
+    // Sort range
+    const [onFilterTable, onDeleteFilter] = useOnFilterTable({
+        theme,
+        createHistory,
+        onChangeTables,
+        onChangeSheets,
+        getEffectiveValue,
+        getFormattedValue,
+        getEffectiveFormat,
+        conditionalFormats,
+        getActiveCell,
+        getSheetName,
+        onRequestCalculate: onRequestCalculateWithoutFormatting,
+        onCommand,
+        onRowVisibilityChange,
+    });
+    // Resize table
+    const onResizeTable = useOnResizeTable({
+        rowCount,
+        columnCount,
+        locale,
+        tables,
+        basicFilter,
+        getActiveCell,
+        createHistory,
+        onChangeTables,
+        onChangeSheetData,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        getFormattedValue,
+        getDependents,
+        onCommand,
+        generatedNames,
+    });
+    // Copy
+    const onCopy = useOnCopy({
+        theme,
+        merges,
+        tables,
+        bandedRanges,
+        cellXfs,
+        sharedStrings,
+        getEffectiveFormat,
+        getFormattedValue,
+        getColumnWidth,
+        getRowHeight,
+        isColumnHidden,
+        isHiddenRow,
+        getCellData,
+    });
+    // Paste
+    const onPaste = useOnPaste({
+        rowCount,
+        columnCount,
+        locale,
+        sheetData,
+        getDataValidationById,
+        preserveFormatting: preserveFormattingOnPaste,
+        maxColumnCount,
+        maxRowCount,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        tables,
+        isHiddenByFilterRow,
+        onRequestFonts,
+        idCreationStrategy,
+        getDependents,
+        getActiveCell,
+        getSheetName,
+        enqueueCalculation,
+        enqueueStructureChange,
+        enqueueGraphOperation,
+        createHistory,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeSelections,
+        onChangeTables,
+        onChangeEmbeds,
+        onChangeActiveCell,
+        getUserEnteredValue,
+        onChangeDataValidations,
+        onError,
+        citations,
+        onChangeCitations,
+        sanitizeHtml,
+        onCommand,
+        generatedNames,
+    });
+    // Create table
+    const { onCreateTable, onRemoveTable, onUpdateTable, onCreateBasicFilter, onInsertTableColumn, onDeleteTableColumn, } = useOnTable({
+        locale,
+        rowCount,
+        columnCount,
+        tables,
+        basicFilter,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        theme,
+        idCreationStrategy,
+        enqueueCalculation,
+        enqueueStructureChange,
+        onChangeSheets,
+        onChangeSheetData,
+        createHistory,
+        onChangeTables,
+        getFormattedValue,
+        getEffectiveValue,
+        onRequestCalculate,
+        getDependents,
+        enqueueGraphOperation,
+        getContentfulRangeAroundCell,
+        getSheetName,
+        onCommand,
+        generatedNames,
+    });
+    // Insert table row
+    const onInsertTableRow = useOnInsertTableRow({
+        rowCount,
+        columnCount,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        createHistory,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        enqueueStructureChange,
+        getActiveCell,
+        getDependents,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        getSheetName,
+        onCommand,
+    });
+    // Delete table row
+    const onDeleteTableRow = useOnDeleteTableRow({
+        columnCount,
+        rowCount,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        createHistory,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        enqueueStructureChange,
+        getDependents,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        getSheetName,
+        onCommand,
+    });
+    // Fill range
+    const onFillRange = useOnFillRange({
+        onFill,
+    });
+    // Embeds
+    const { onDeleteEmbed, onMoveEmbed, onResizeEmbed, onCreateEmbed, onRequestEditEmbed, } = useOnEmbeds({
+        onChangeEmbeds,
+        createHistory,
+        onCommand,
+    });
+    // Slicers
+    const { onDeleteSlicer, onMoveSlicer, onResizeSlicer, onCreateSlicer, onUpdateSlicer, onRequestEditSlicer, } = useSlicers({
+        onChangeSlicers,
+        createHistory,
+        onCommand,
+    });
+    // Show modal dialog for table editor
+    const onRequestEditTable = useOnRequestEditTable();
+    // Show modal dialog for table editor
+    const onRequestDefineNamedRange = useOnRequestDefineNamedRange({
+        namedRanges,
+    });
+    // Show modal dialog for table editor
+    const onRequestUpdateNamedRange = useOnRequestUpdateNamedRange();
+    // Update named range
+    const onUpdateNamedRange = useOnUpdateNamedRange({
+        locale,
+        getDependents,
+        getActiveCell,
+        enqueueCalculation,
+        createHistory,
+        onChangeNamedRanges,
+        onChangeSheetData,
+        onCommand,
+    });
+    // Update named range
+    const onCreateNamedRange = useOnCreateNamedRange({
+        enqueueCalculation,
+        createHistory,
+        onChangeNamedRanges,
+        onCommand,
+    });
+    // Delete named range
+    const onDeleteNamedRange = useOnDeleteNamedRange({
+        getDependents,
+        enqueueCalculation,
+        createHistory,
+        onChangeNamedRanges,
+        onCommand,
+    });
+    // Freeze rows and columns
+    const [onFreezeRow, onFreezeColumn] = useOnFreeze({
+        createHistory,
+        onChangeSheets,
+        onChangeEmbeds,
+        onChangeCharts,
+        onCommand,
+    });
+    // Request insert image
+    const onRequestInsertImage = useOnRequestInsertImage();
+    // Insert image
+    const onInsertImage = useOnInsertImage({
+        locale,
+        idCreationStrategy,
+        createHistory,
+        enqueueCalculation,
+        onChangeSheetData,
+        onChangeEmbeds,
+        onCommand,
+    });
+    // Request insert image
+    const onRequestInsertLink = useOnRequestInsertLink();
+    // Insert link
+    const [onInsertLink, onRemoveLink, onSelectLink] = useOnInsertLink({
+        locale,
+        sharedStringRegistry,
+        cellXfsRegistry,
+        getSheetId,
+        getDataValidationById,
+        createHistory,
+        enqueueCalculation,
+        onChangeSheetData,
+        onCommand,
+    });
+    // Insert checkbox
+    const onInsertCheckbox = useOnInsertCheckbox({
+        locale,
+        createHistory,
+        enqueueCalculation,
+        onChangeSheetData,
+        onCommand,
+    });
+    // Banded range
+    const { onAddBandedRange, onRemoveBandedRange } = useOnBandedRanges({
+        createHistory,
+        onChangeBandedRanges,
+        onCommand,
+    });
+    // Notes
+    const onUpdateNote = useOnUpdateNote({
+        locale,
+        createHistory,
+        onChangeSheetData,
+        onCommand,
+    });
+    // Insert note
+    const onInsertNote = useOnInsertNote();
+    // Sort range
+    const onSortRange = useOnSortRange({
+        locale,
+        sharedStringRegistry,
+        createHistory,
+        enqueueCalculation,
+        enqueueStructureChange,
+        enqueueGraphOperation,
+        onChangeSheetData,
+        getDependents,
+        isHiddenRow,
+        getFrozenRowCount,
+        getSheetName,
+        getEffectiveFormat,
+        theme,
+    });
+    // Protect range
+    const { onProtectRange, onUnProtectRange } = useOnProtectRange({
+        idCreationStrategy,
+        createHistory,
+        onChangeProtectedRanges,
+        onCommand,
+    });
+    // Indent
+    const { onIncreaseIndent, onDecreaseIndent, onChangeIndent } = useIndent({
+        locale,
+        createHistory,
+        onChangeSheetData,
+        enqueueCalculation,
+        cellXfsRegistry,
+        getDataValidationById,
+        onCommand,
+    });
+    const onAutoResize = useOnAutoResize({
+        onChangeSheets,
+        createHistory,
+        getActiveCell,
+        getRowHeight: getFinalRowHeight,
+        getColumnWidth: getFinalColumnWidth,
+        getCellDimensions,
+        isMergedCell,
+        onCommand,
+    });
+    // Request format cells
+    const onRequestFormatCells = useOnRequestFormatCells();
+    // Resize row, col dialog
+    const onRequestResize = useOnRequestResize();
+    // Insert time
+    const onInsertTime = useOnInsertTime({
+        locale,
+    });
+    // Insert date
+    const onInsertDate = useOnInsertDate({
+        locale,
+    });
+    // Insert datetime
+    const onInsertDateTime = useOnInsertDateTime({
+        locale,
+    });
+    // Insert date
+    const onInsertAutoSum = useOnInsertAutoSum({
+        getEffectiveFormat,
+        getEffectiveValue,
+        isHiddenRow,
+    });
+    // Request conditional format
+    const onRequestConditionalFormat = useOnRequestConditionalFormat();
+    const getEffectiveValuesFromRange = useGetEffectiveValuesFromRange();
+    /**
+     * Batch stream
+     */
+    const onChangeBatchStream = useOnChangeBatchStream({
+        locale,
+        getDataValidationById,
+        onChangeSheetData,
+        onChangeSheets,
+        getEffectiveValuesFromRange,
+        getFormattedValue,
+        getCellDimensions,
+        getRowHeight: getCurrentRowHeight,
+        isMergedCell,
+        onRequestCalculate: onRequestCalculateWithoutFormatting,
+        getPrecedentsFromFormulaString,
+        getSheetId,
+        cellXfsRegistry,
+        enqueueCalculation,
+        onStreamStart,
+        onStreamProgress,
+        onStreamEnd,
+    });
+    // Conditional format actions
+    const { onCreateConditionalFormattingRule, onUpdateConditionalFormattingRule, onDeleteConditionalFormattingRule, onPreviewConditionalFormattingRule, } = useConditionalFormattingRules({
+        enqueueCalculation,
+        onChangeConditionalFormats,
+        createHistory,
+    });
+    // Data validations
+    const { onCreateDataValidationRule, onUpdateDataValidationRule, onDeleteDataValidationRule, onDeleteDataValidationRules, } = useDataValidationRules({
+        locale,
+        onChangeDataValidations,
+        onChangeSheetData,
+        enqueueCalculation,
+        createHistory,
+        getEffectiveValuesFromRange,
+        getSheetName,
+        cellXfsRegistry,
+        sharedStringRegistry,
+    });
+    // Request datavalidation
+    const onRequestDataValidation = useOnRequestDataValidation({
+        onCreateDataValidationRule,
+    });
+    // Find replace
+    const onFindReplace = useOnFindReplace({
+        locale,
+        createHistory,
+        enqueueCalculation,
+        enqueueStructureChange,
+        onChangeSheetData,
+        sharedStringRegistry,
+        onCommand,
+    });
+    // Read excel file
+    const { importExcelFile, isImportingExcelfile, generateStatePatches } = useOnImportExcelFile({
+        enableExcelImportHistory,
+        onRequestFonts,
+        onChangeHistory,
+        onChangeCharts,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        onChangeEmbeds,
+        onChangeConditionalFormats,
+        onChangeCellXfs,
+        onChangeNamedRanges,
+        onChangeDataValidations,
+        onCreateDataValidationRule,
+        onChangeTheme,
+        onClearHistory,
+        evaluateConditionalFormatting,
+        evaluateDataValidations,
+        clearRangeCache,
+        onChangeSharedStrings,
+        onChangeSlicers,
+        // Phase D1 — wire pivot tables through the import path
+        onChangePivotTables,
+        onConfirm,
+        onPrompt,
+    });
+    // Read csv file
+    const { importCSVFile } = useOnImportCSV({
+        sheetId: activeSheetId,
+        activeCell,
+        rowCount,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeSharedStrings,
+        onChangeCellXfs,
+        createHistory,
+        sharedStringRegistry,
+        enabledSharedStrings: sharedStringRegistry.active,
+        enableCellXfsRegistry: cellXfsRegistry.active,
+        enqueueCalculation,
+        clearRangeCache,
+        getDependents,
+    });
+    // Legacy Read csv file
+    const { importCSVFile: importCSVFileLegacy } = useOnImportCSVLegacy({
+        sheetId: activeSheetId,
+        activeCell,
+        rowCount,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeSharedStrings,
+        createHistory,
+        sharedStringRegistry,
+        enabledSharedStrings: sharedStringRegistry.active,
+        enqueueCalculation,
+        getDependents,
+    });
+    // Drag n drop files
+    const { onDragOver, onDrop, onInsertFile } = useOnDragnDrop({
+        sheetId: activeSheetId,
+        locale,
+        fileSizeLimit,
+        enableExcelfileDragDrop,
+        importExcelFile,
+        importCSVFile,
+        onChangeActiveCell,
+        getActiveCell,
+        onChangeSheetData,
+        onChangeEmbeds,
+        createHistory,
+        enqueueCalculation,
+        onError,
+        calculateNow,
+        onIterativeCalculationEnabled,
+        enable: enableDragnDrop,
+        enableCellXfsRegistry: cellXfsRegistry.active,
+        enabledSharedStrings: sharedStringRegistry.active,
+        onConfirm,
+        onPrompt,
+    });
+    // Split text to columns
+    const onSplitTextToColumns = useSplitTextToColumns({
+        createHistory,
+        enqueueCalculation,
+        onChangeSheetData,
+        locale,
+        getFormattedValue,
+        onChangeSelections,
+        onCommand,
+    });
+    // Remove duplicates
+    const onRemoveDuplicates = useOnRemoveDuplicates({
+        createHistory,
+        enqueueCalculation,
+        onChangeSheetData,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getFormattedValue,
+        onCommand,
+    });
+    // Trace dependents and precedents
+    const { arrows, onRemoveArrows, onTraceDependents, onTracePrecedents } = useOnTraceDependentsPrecedents({
+        getDependents,
+        getPrecedents,
+    });
+    // Comments
+    const { onInsertComment, onRemoveComment } = useComments({
+        onChangeSheetData,
+        createHistory,
+        locale,
+    });
+    // Citations
+    const { onCreateCitation, onUpdateCitation, onRemoveCitationFromCell, onDeleteCitation, } = useCitations({
+        onChangeSheetData,
+        onChangeCitations,
+        createHistory,
+        locale,
+    });
+    return {
+        activeCellBySheetId,
+        selectionsBySheetId,
+        activeCell,
+        activeSheetId,
+        selections,
+        showGridLines,
+        showRowColHeaders,
+        zoomScale,
+        rowCount,
+        columnCount,
+        frozenColumnCount,
+        frozenRowCount,
+        rowMetadata,
+        columnMetadata,
+        merges,
+        bandedRanges,
+        basicFilter,
+        spreadsheetColors,
+        isDarkMode,
+        canUndo,
+        canRedo,
+        getDataRowCount,
+        getDataColumnCount,
+        onRedo,
+        onUndo,
+        applyPatch,
+        getCellData,
+        getMentionsFromCell,
+        getTextFormatRuns,
+        getSheetName,
+        getSheetId,
+        getUserEnteredFormat,
+        getEffectiveFormat,
+        getSeriesValuesFromRange,
+        getDomainValuesFromRange,
+        getUserEnteredValuesFromRange,
+        getFormattingFromRange,
+        getFormulasFromRange,
+        getEffectiveValue,
+        getUserEnteredValue,
+        getFormattedValue,
+        createHistory,
+        onRequestCalculate,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        addFormulaToGraph,
+        calculateNow,
+        evaluateConditionalFormatting,
+        evaluateConditionalFormattingForViewport,
+        evaluateDataValidations,
+        evaluateDataValidationsForViewport,
+        clearEvaluatedCellsCache,
+        onViewPortChange,
+        reevaluateDerivationsForCells,
+        onChangeActiveCell,
+        onChangeSelections: onChangeSelectionsInterceptor,
+        onChangeActiveSheet,
+        onSelectNextSheet,
+        onSelectPreviousSheet,
+        onChange,
+        onChangeBatch,
+        onChangeBatchStream,
+        onChangeFormatting,
+        onRepeatFormatting,
+        onClearFormatting,
+        onMergeCells,
+        onUnMergeCells,
+        onResize,
+        onChangeBorder,
+        onChangeDecimals,
+        onChangeSheetTabColor,
+        onRenameSheet,
+        onRequestDeleteSheet,
+        onDeleteSheet,
+        onDelete,
+        onHideSheet,
+        onShowSheet,
+        onProtectSheet,
+        onUnProtectSheet,
+        onMoveSheet,
+        onCreateNewSheet,
+        onUpdateSheet,
+        onDuplicateSheet,
+        onHideColumn,
+        onShowColumn,
+        onHideRow,
+        onShowRow,
+        onGroupRows,
+        onUngroupRows,
+        onCollapseRowGroup,
+        onExpandRowGroup,
+        onGroupColumns,
+        onUngroupColumns,
+        onCollapseColumnGroup,
+        onExpandColumnGroup,
+        onSetOutlineDepth,
+        onFill,
+        onFillRange,
+        onMoveEmbed,
+        onResizeEmbed,
+        onDeleteEmbed,
+        onCreateEmbed,
+        onRequestEditEmbed,
+        onMoveSlicer,
+        onResizeSlicer,
+        onDeleteSlicer,
+        onCreateSlicer,
+        onUpdateSlicer,
+        onRequestEditSlicer,
+        onDeleteRow,
+        onDeleteColumn,
+        onDeleteCellsShiftUp,
+        onDeleteCellsShiftLeft,
+        onInsertCellsShiftRight,
+        onInsertCellsShiftDown,
+        onInsertRow,
+        onInsertColumn,
+        onMoveColumns,
+        onMoveRows,
+        onMoveSelection,
+        onSortColumn,
+        onSortTable,
+        onFilterTable,
+        onDeleteFilter,
+        onResizeTable,
+        onInsertTableColumn,
+        onInsertTableRow,
+        onDeleteTableColumn,
+        onDeleteTableRow,
+        onCopy,
+        onPaste,
+        onCreateBasicFilter,
+        onCreateTable,
+        onRemoveTable,
+        onRequestEditTable,
+        onUpdateTable,
+        onRequestDefineNamedRange,
+        onRequestUpdateNamedRange,
+        onUpdateNamedRange,
+        onCreateNamedRange,
+        onDeleteNamedRange,
+        onDragOver,
+        onDrop,
+        onInsertFile,
+        onFreezeColumn,
+        onFreezeRow,
+        onChangeSpreadsheetTheme,
+        onAddBandedRange,
+        onRemoveBandedRange,
+        onUpdateNote,
+        onInsertNote,
+        onSortRange,
+        onProtectRange,
+        onUnProtectRange,
+        getNonEmptyRowCount,
+        getNonEmptyColumnCount,
+        getSheetRowCount,
+        getSheetColumnCount,
+        onIncreaseIndent,
+        onDecreaseIndent,
+        onChangeIndent,
+        onRequestResize,
+        onAutoResize,
+        getColumnarDataFromRange,
+        onInsertTime,
+        onInsertDate,
+        onInsertDateTime,
+        onRequestInsertLink,
+        onInsertLink,
+        onRemoveLink,
+        onSelectLink,
+        onRequestInsertImage,
+        onInsertImage,
+        onInsertCheckbox,
+        onRequestFormatCells,
+        onRequestConditionalFormat,
+        onCreateConditionalFormattingRule,
+        onUpdateConditionalFormattingRule,
+        onDeleteConditionalFormattingRule,
+        onPreviewConditionalFormattingRule,
+        onRequestDataValidation,
+        onDeleteDataValidationRules,
+        onDeleteDataValidationRule,
+        onCreateDataValidationRule,
+        onUpdateDataValidationRule,
+        getDependencyGraph,
+        updateDependencyGraph,
+        onFindReplace,
+        onInsertAutoSum,
+        // cell format registry
+        cellXfsRegistry,
+        onChangeCellXfs,
+        // shared strings registry
+        sharedStringRegistry,
+        // Import excel file
+        importExcelFile,
+        isImportingExcelfile,
+        generateStatePatches,
+        // Import csv
+        importCSVFile,
+        importCSVFileLegacy,
+        // Paint format
+        paintFormat,
+        onSavePaintFormat,
+        isPaintFormatActive,
+        onApplyPaintFormat,
+        // Sheet properties
+        getSheetProperties,
+        getEffectiveExtendedValue,
+        getUserEnteredExtendedValue,
+        // Error value
+        getErrorValue,
+        // Split
+        onSplitTextToColumns,
+        // Remove duplicates
+        onRemoveDuplicates,
+        // Add rows
+        onRequestAddRows,
+        // Dependents
+        getDependents,
+        // Precedents
+        getPrecedents,
+        // Data validation
+        getDataValidation,
+        // Trace dependents and precendents
+        arrows,
+        onRemoveArrows,
+        onTraceDependents,
+        onTracePrecedents,
+        onClearHistory,
+        // Locale change
+        onChangeLocale,
+        // Comments
+        onInsertComment,
+        onRemoveComment,
+        // Citations
+        onCreateCitation,
+        onUpdateCitation,
+        onRemoveCitationFromCell,
+        onDeleteCitation,
+    };
+};