@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-sheet-properties.js

@@ -0,0 +1,1019 @@
+import { __assign, __read, __values } from "tslib";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { isCellWithinBounds } from "@rowsncolumns/grid";
+import { DEFAULT_COLUMN_COUNT, DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_COUNT, DEFAULT_ROW_HEIGHT, isStyleReference, useCallbackRef, } from "@rowsncolumns/spreadsheet";
+import { cellToAddress, getCurrentLocale, getExtendedValueError, isNil, iterateCells, sortSheetsByIndex, } from "@rowsncolumns/utils";
+import { getCellEffectiveValue, getCellFormattedValue, getCellUserEnteredFormat, getCellUserEnteredValue, getExtendedValueBool, getExtendedValueFormula, getExtendedValueNumber, getExtendedValueString, getStyleId, } from "@rowsncolumns/utils";
+import { useCallback, useMemo, useRef } from "react";
+import { useTokenizer } from "@rowsncolumns/spreadsheet";
+import { buildConditionalFormatExpression, isConditionalFormatFormulaRule, } from "../api/conditional-format";
+import { buildDataValidationExpression, isDataValidationFormulaRule, } from "../api/data-validation";
+import { formulaToRelativeReference } from "../api/formula";
+import { FormattedValueCache, FormulaFormatCache } from "../api/format-caches";
+import { deriveEffectiveNumberFormatFromPrecedents } from "../api/immer-utils";
+import { createFormattedValue, detectValueType } from "../api/datatype";
+import { LOADING_VALUE } from "../sheet-cell";
+import { getSharedStringRuns, getSharedStringText, } from "../types";
+/**
+ * Build a "format fingerprint" for the precedents of a formula cell — an
+ * array of effective `numberFormat` references, one per precedent. Used
+ * to invalidate the derived-format cache when a precedent's format
+ * changes (the precedent's value may stay the same, so value-only
+ * invalidation isn't enough).
+ *
+ * Uses a resolver to get the precedent's effective `numberFormat` —
+ * either `uf.numberFormat` (plain cell) or the recursively-derived
+ * format (formula cell). That way a change deep in the chain
+ * (`A1` → `B1=A1` → `C1=B1`) invalidates `C1`'s cache: `B1`'s derived
+ * format object identity changes, so `C1`'s fingerprint mismatches.
+ *
+ * Only the **anchor cell** is sampled for range references — matches
+ * Excel's first-cell inheritance behaviour and keeps cost O(1) per range
+ * (vs O(n) walking the whole range). Trade-off: changing a non-anchor
+ * cell's format inside a range won't invalidate the cache.
+ */
+var collectPrecedentFormatRefs = function (precedents, defaultSheetId, resolveNumberFormat) {
+    var e_1, _a;
+    var _b;
+    var refs = [];
+    try {
+        for (var precedents_1 = __values(precedents), precedents_1_1 = precedents_1.next(); !precedents_1_1.done; precedents_1_1 = precedents_1.next()) {
+            var p = precedents_1_1.value;
+            var position = p.position;
+            if (!position)
+                continue;
+            var sheetId = (_b = position.sheetId) !== null && _b !== void 0 ? _b : defaultSheetId;
+            var row = void 0;
+            var col = void 0;
+            if ("rowIndex" in position) {
+                row = position.rowIndex;
+                col = position.columnIndex;
+            }
+            else if ("startRowIndex" in position) {
+                row = position.startRowIndex;
+                col = position.startColumnIndex;
+            }
+            else {
+                continue;
+            }
+            refs.push(resolveNumberFormat(sheetId, row, col));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (precedents_1_1 && !precedents_1_1.done && (_a = precedents_1.return)) _a.call(precedents_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return refs;
+};
+var shallowArrayRefEqual = function (a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (var i = 0; i < a.length; i++) {
+        if (!Object.is(a[i], b[i]))
+            return false;
+    }
+    return true;
+};
+export var useSheetProperties = function (_a) {
+    var conditionalFormats = _a.conditionalFormats, sheetData = _a.sheetData, sheets = _a.sheets, activeSheetId = _a.activeSheetId, dataValidations = _a.dataValidations, protectFormulas = _a.protectFormulas, getEffectiveStructuredValue = _a.getEffectiveStructuredValue, cellXfs = _a.cellXfs, cellXfsRegistry = _a.cellXfsRegistry, cellStyles = _a.cellStyles, sharedStrings = _a.sharedStrings, locale = _a.locale, use1904 = _a.use1904, lenientGrouping = _a.lenientGrouping, getPrecedents = _a.getPrecedents;
+    /* Callback refs */
+    var getEffectiveStructuredValueRef = useCallbackRef(getEffectiveStructuredValue);
+    var tokenizer = useTokenizer();
+    /**
+     * Per-formula-cell number-format cache. Stores the value + precedent-uf
+     * fingerprint the format was derived from so we can invalidate cheaply
+     * when either changes (matches Excel's "format depends on result"
+     * semantics). Walking precedents is intensive — this avoids it on every
+     * render. LRU-bounded to keep memory predictable over long sessions.
+     */
+    var formulaNumberFormatCache = useRef(new FormulaFormatCache());
+    /**
+     * Two-level WeakMap cache for the (eff, der) → merged result.
+     * Keyed first by the user-entered format reference, then by the derived
+     * format reference. Both inputs already have stable identity per their
+     * own caches, so the same merged object is returned across renders unless
+     * one of the inputs actually changed. GC-friendly: when either input is
+     * replaced, the corresponding entry becomes unreachable and is collected.
+     */
+    var mergedFormatCache = useRef(new WeakMap());
+    /**
+     * Per-(locale, pattern, value) formatted-value cache. Shared across all
+     * formula cells — `createFormattedValue` is the expensive call we're
+     * memoising, and many cells share the same (value, pattern) tuple.
+     * LRU-bounded.
+     */
+    var formulaFormattedValueCache = useRef(new FormattedValueCache());
+    // Clear both formula caches on locale change. The fingerprints don't
+    // include locale (value + precedent refs are locale-agnostic), but
+    // the *output* depends on locale — synthesized DATE/TIME default
+    // patterns (`m/d/yyyy` vs `d/m/yyyy`), formatted-value strings, etc.
+    //
+    // Done **during render** (not via `useEffect`) because the cell
+    // renderer reads from these caches inside its `useMemo` in the same
+    // render pass. A `useEffect` fires *after* commit — by then the stale
+    // format has already painted, and nothing else triggers a follow-up
+    // render to correct it (the user reported `=TODAY()` staying on the
+    // old locale's pattern after switching). Comparing the previous
+    // locale against the current one in render lets the clear happen
+    // before any cache read in this pass. Mutating a ref during render
+    // is safe here: the work is idempotent (we guard on the ref so a
+    // single render only clears once) and there are no external side
+    // effects.
+    var prevLocaleRef = useRef(locale);
+    if (prevLocaleRef.current !== locale) {
+        formulaFormattedValueCache.current.clear();
+        formulaNumberFormatCache.current.clear();
+        prevLocaleRef.current = locale;
+    }
+    // Note: we deliberately do NOT clear `formulaNumberFormatCache` on
+    // row/column insert/delete. The cache fingerprint `(value,
+    // precedentUfRefs)` self-corrects on structural changes — after a shift
+    // the cell at a given `(sheetId, r, c)` is a different cell with
+    // different value/precedent refs, so the fingerprint mismatches and the
+    // entry is recomputed naturally. Stale entries that survive sit until
+    // LRU eviction; they're memory, not a correctness issue.
+    // Sheet property by id
+    var _b = __read(useMemo(function () {
+        var e_2, _a;
+        var sheetnameById = new Map();
+        var sheetIdByName = new Map();
+        var sheetPropertiesById = new Map();
+        var sheetMetaDataById = new Map();
+        try {
+            for (var sheets_1 = __values(sheets), sheets_1_1 = sheets_1.next(); !sheets_1_1.done; sheets_1_1 = sheets_1.next()) {
+                var sheet = sheets_1_1.value;
+                if (sheet) {
+                    var sheetId = sheet.sheetId, title = sheet.title, _b = sheet.rowCount, rowCount = _b === void 0 ? DEFAULT_ROW_COUNT : _b, _c = sheet.columnCount, columnCount = _c === void 0 ? DEFAULT_COLUMN_COUNT : _c, rowMetadata = sheet.rowMetadata, columnMetadata = sheet.columnMetadata, frozenRowCount = sheet.frozenRowCount, frozenColumnCount = sheet.frozenColumnCount;
+                    sheetnameById.set(sheetId, title);
+                    sheetIdByName.set(title, sheetId);
+                    sheetPropertiesById.set(sheetId, {
+                        rowCount: rowCount !== null && rowCount !== void 0 ? rowCount : DEFAULT_ROW_COUNT,
+                        columnCount: columnCount !== null && columnCount !== void 0 ? columnCount : DEFAULT_COLUMN_COUNT,
+                        frozenRowCount: frozenRowCount !== null && frozenRowCount !== void 0 ? frozenRowCount : 0,
+                        frozenColumnCount: frozenColumnCount !== null && frozenColumnCount !== void 0 ? frozenColumnCount : 0,
+                    });
+                    sheetMetaDataById.set(sheetId, {
+                        rowMetadata: rowMetadata,
+                        columnMetadata: columnMetadata,
+                    });
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (sheets_1_1 && !sheets_1_1.done && (_a = sheets_1.return)) _a.call(sheets_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return [
+            sheetnameById,
+            sheetIdByName,
+            sheetPropertiesById,
+            sheetMetaDataById,
+        ];
+    }, [sheets]), 4), sheetnameBySheetId = _b[0], sheetIdByName = _b[1], sheetPropertiesById = _b[2], sheetMetaDataById = _b[3];
+    // Get Conditional format formula value
+    var conditionalFormatById = useMemo(function () {
+        var e_3, _a;
+        var map = new Map();
+        if (conditionalFormats) {
+            try {
+                for (var conditionalFormats_1 = __values(conditionalFormats), conditionalFormats_1_1 = conditionalFormats_1.next(); !conditionalFormats_1_1.done; conditionalFormats_1_1 = conditionalFormats_1.next()) {
+                    var rule = conditionalFormats_1_1.value;
+                    map.set(rule.id, rule);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (conditionalFormats_1_1 && !conditionalFormats_1_1.done && (_a = conditionalFormats_1.return)) _a.call(conditionalFormats_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+        return map;
+    }, [conditionalFormats]);
+    // By Id
+    var dataValidationsById = useMemo(function () {
+        var e_4, _a;
+        var map = new Map();
+        try {
+            for (var _b = __values(dataValidations !== null && dataValidations !== void 0 ? dataValidations : []), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var d = _c.value;
+                map.set(d.id, d);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return map;
+    }, [dataValidations]);
+    // Get conditional formatting
+    var getConditionalFormattingById = useCallback(function (id) {
+        return conditionalFormatById.get(id);
+    }, [conditionalFormatById]);
+    // Get data validations
+    var getDataValidationById = useCallback(function (id) {
+        return dataValidationsById.get(id);
+    }, [dataValidationsById]);
+    // Get column width
+    var getColumnWidth = useCallback(function (sheetId, columnIndex) {
+        var _a, _b, _c, _d;
+        return ((_d = (_c = (_b = (_a = sheetMetaDataById.get(sheetId)) === null || _a === void 0 ? void 0 : _a.columnMetadata) === null || _b === void 0 ? void 0 : _b[columnIndex]) === null || _c === void 0 ? void 0 : _c.size) !== null && _d !== void 0 ? _d : DEFAULT_COLUMN_WIDTH);
+    }, [sheetMetaDataById]);
+    // Check if a row is resized by user
+    var isRowResizedByUser = useCallback(function (sheetId, rowIndex) { var _a, _b, _c; return (_c = (_b = (_a = sheetMetaDataById.get(sheetId)) === null || _a === void 0 ? void 0 : _a.rowMetadata) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.resizedByUser; }, [sheetMetaDataById]);
+    // Get row height
+    var getRowHeight = useCallback(function (sheetId, rowIndex) {
+        var _a, _b, _c, _d;
+        return ((_d = (_c = (_b = (_a = sheetMetaDataById.get(sheetId)) === null || _a === void 0 ? void 0 : _a.rowMetadata) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.size) !== null && _d !== void 0 ? _d : DEFAULT_ROW_HEIGHT);
+    }, [sheetMetaDataById]);
+    // Get row count
+    var getSheetRowCount = useCallback(function (sheetId) {
+        var _a, _b;
+        return (_b = (_a = sheetPropertiesById.get(sheetId)) === null || _a === void 0 ? void 0 : _a.rowCount) !== null && _b !== void 0 ? _b : DEFAULT_ROW_COUNT;
+    }, [sheetPropertiesById]);
+    // Get column count
+    var getSheetColumnCount = useCallback(function (sheetId) {
+        var _a, _b;
+        return ((_b = (_a = sheetPropertiesById.get(sheetId)) === null || _a === void 0 ? void 0 : _a.columnCount) !== null && _b !== void 0 ? _b : DEFAULT_COLUMN_COUNT);
+    }, [sheetPropertiesById]);
+    // Non blank rows
+    var getDataRowCount = useCallback(function (sheetId) {
+        var _a, _b;
+        if (sheetId === void 0) { sheetId = activeSheetId; }
+        return (_b = (_a = sheetData === null || sheetData === void 0 ? void 0 : sheetData[sheetId]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : undefined;
+    }, [sheetData, activeSheetId]);
+    // Get non empty row count
+    var getNonEmptyRowCount = useCallback(function (sheetId) { var _a, _b; return (_b = (_a = sheetData === null || sheetData === void 0 ? void 0 : sheetData[sheetId]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : undefined; }, [sheetData]);
+    // Number of columns that have data in a row
+    var getNonEmptyColumnCount = useCallback(function (sheetId, rowIndex) {
+        var _a, _b, _c, _d;
+        return (_d = (_c = (_b = (_a = sheetData === null || sheetData === void 0 ? void 0 : sheetData[sheetId]) === null || _a === void 0 ? void 0 : _a[rowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : undefined;
+    }, [sheetData]);
+    // Get column count for a sheet
+    var getDataColumnCount = useCallback(function (sheetId) {
+        var _a, _b, _c;
+        var cur = 0;
+        var rowData = sheetData === null || sheetData === void 0 ? void 0 : sheetData[sheetId];
+        if (!rowData) {
+            return 0;
+        }
+        for (var rowIndex in rowData) {
+            cur = Math.max(cur, ((_c = (_b = (_a = rowData === null || rowData === void 0 ? void 0 : rowData[rowIndex]) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) - 1);
+        }
+        return cur;
+    }, [sheetData]);
+    // Get non empty row count
+    var getActualRowCount = useCallback(function (sheetId) { var _a, _b; return (_b = (_a = sheetData === null || sheetData === void 0 ? void 0 : sheetData[sheetId]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0; }, [sheetData]);
+    // Get frozen row count
+    var getFrozenRowCount = useCallback(function (sheetId) { var _a, _b; return (_b = (_a = sheetPropertiesById.get(sheetId)) === null || _a === void 0 ? void 0 : _a.frozenRowCount) !== null && _b !== void 0 ? _b : 0; }, [sheetPropertiesById]);
+    // Hidden row
+    var isHiddenRow = useCallback(function (sheetId, rowIndex) {
+        var _a, _b;
+        var metaData = (_b = (_a = sheetMetaDataById.get(sheetId)) === null || _a === void 0 ? void 0 : _a.rowMetadata) === null || _b === void 0 ? void 0 : _b[rowIndex];
+        return Boolean((metaData === null || metaData === void 0 ? void 0 : metaData.hiddenByUser) || (metaData === null || metaData === void 0 ? void 0 : metaData.hiddenByFilter));
+    }, [sheetMetaDataById]);
+    // Hidden by filter row
+    var isHiddenByFilterRow = useCallback(function (sheetId, rowIndex) {
+        var _a, _b;
+        var metaData = (_b = (_a = sheetMetaDataById.get(sheetId)) === null || _a === void 0 ? void 0 : _a.rowMetadata) === null || _b === void 0 ? void 0 : _b[rowIndex];
+        return Boolean(metaData === null || metaData === void 0 ? void 0 : metaData.hiddenByFilter);
+    }, [sheetMetaDataById]);
+    // Hidden column
+    var isColumnHidden = useCallback(function (sheetId, columnIndex) {
+        var _a, _b;
+        var metaData = (_b = (_a = sheetMetaDataById.get(sheetId)) === null || _a === void 0 ? void 0 : _a.columnMetadata) === null || _b === void 0 ? void 0 : _b[columnIndex];
+        return Boolean((metaData === null || metaData === void 0 ? void 0 : metaData.hiddenByUser) || (metaData === null || metaData === void 0 ? void 0 : metaData.hiddenByFilter));
+    }, [sheetMetaDataById]);
+    // Get sheet count. Used for formuls
+    var getSheetCount = useCallbackRef(useCallback(function () { return sheets.length; }, [sheets]));
+    // Get sheet name. Used for formuls
+    var getSheetName = useCallbackRef(useCallback(function (sheetId) { return sheetnameBySheetId.get(sheetId); }, [sheetnameBySheetId]));
+    // Get sheet Id by sheet name
+    var getSheetId = useCallbackRef(useCallback(function (sheetname) {
+        return sheetIdByName.get(sheetname);
+    }, [sheetIdByName]));
+    // Ordered sheets
+    var sheetIndexByName = useMemo(function () {
+        var orderedSheets = sortSheetsByIndex(sheets, true);
+        var map = new Map();
+        orderedSheets.forEach(function (sheet, index) {
+            map.set(sheet.title, index + 1);
+        });
+        return map;
+    }, [sheets]);
+    // For calculator
+    var getSheetIndex = useCallbackRef(useCallback(function (sheetName) {
+        var resolvedName = sheetName !== null && sheetName !== void 0 ? sheetName : sheetnameBySheetId.get(activeSheetId);
+        if (!resolvedName) {
+            return undefined;
+        }
+        return sheetIndexByName.get(resolvedName);
+    }, [sheetnameBySheetId, activeSheetId]));
+    // Get sheet Id by sheet name
+    var getSheetProperties = useCallbackRef(useCallback(function (sheetId) {
+        return sheetPropertiesById.get(sheetId);
+    }, [sheetPropertiesById]));
+    // Get cell data of active sheet
+    var getCellData = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = sheetData === null || sheetData === void 0 ? void 0 : sheetData[sheetId]) === null || _a === void 0 ? void 0 : _a[rowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[columnIndex];
+    }, [sheetData]);
+    /**
+     * Get mentions from a cell
+     */
+    var getMentionsFromCell = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        if (isNil(cellData === null || cellData === void 0 ? void 0 : cellData.ss) || !sharedStrings)
+            return undefined;
+        // Mentions ride along on the SharedStrings rich entry the cell
+        // points at, same as bold/italic runs.
+        var runs = getSharedStringRuns(sharedStrings.get(String(cellData.ss)));
+        return runs === null || runs === void 0 ? void 0 : runs.filter(function (run) { return run.nodeType === "mention"; });
+    }, [getCellData, sharedStrings]);
+    /**
+     * Get textFormat runs from a cell
+     */
+    var getTextFormatRuns = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        if (isNil(cellData === null || cellData === void 0 ? void 0 : cellData.ss) || !sharedStrings)
+            return undefined;
+        // Rich-text runs are persisted on the SharedStrings entry the
+        // cell points at via `ss`. Returns `undefined` when the entry
+        // is plain or the cell isn't interned.
+        return getSharedStringRuns(sharedStrings.get(String(cellData.ss)));
+    }, [getCellData, sharedStrings]);
+    /**
+     * Get hyperlink runs from a cell
+     */
+    var getHyperLink = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        return cellData === null || cellData === void 0 ? void 0 : cellData.hyperlink;
+    }, [getCellData]);
+    var getHyperlinkText = useCallback(function (hyperlink) {
+        if (!hyperlink) {
+            return undefined;
+        }
+        if (typeof hyperlink === "string") {
+            return hyperlink;
+        }
+        if (hyperlink.kind === "external") {
+            return hyperlink.url;
+        }
+        return hyperlink.location;
+    }, []);
+    var getSharedStringValue = useCallback(function (cellData) {
+        if ((cellData === null || cellData === void 0 ? void 0 : cellData.ss) == null || !sharedStrings) {
+            return undefined;
+        }
+        // SharedStrings may hold a plain string OR a rich object
+        // (`{text, runs}`). Callers that need the displayed text get a
+        // string here; the runs are surfaced separately via
+        // `getTextFormatRuns`.
+        var value = sharedStrings.get(String(cellData.ss));
+        return getSharedStringText(value);
+    }, [sharedStrings]);
+    var getEffectiveValue = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var _a, _b;
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        if (!cellData) {
+            return undefined;
+        }
+        // Check for shared strings
+        var sharedStringValue = getSharedStringValue(cellData);
+        if (!isNil(sharedStringValue)) {
+            return sharedStringValue;
+        }
+        var effectiveValue = getCellEffectiveValue(cellData);
+        if (!effectiveValue) {
+            return undefined;
+        }
+        return ((_b = (_a = getExtendedValueBool(effectiveValue)) !== null && _a !== void 0 ? _a : getExtendedValueNumber(effectiveValue)) !== null && _b !== void 0 ? _b : getExtendedValueString(effectiveValue));
+    }, [getCellData, getSharedStringValue]);
+    // For backwards compat
+    var getEffectiveExtendedValue = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        var effectiveValue = getCellEffectiveValue(cellData);
+        var errorValue = getExtendedValueError(effectiveValue);
+        if (errorValue) {
+            return effectiveValue;
+        }
+        var sharedStringValue = getSharedStringValue(cellData);
+        if (sharedStringValue !== undefined) {
+            return { sv: sharedStringValue };
+        }
+        return effectiveValue;
+    }, [getCellData, getSharedStringValue]);
+    // For backwards compat
+    var getUserEnteredExtendedValue = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        var sharedStringValue = getSharedStringValue(cellData);
+        if (sharedStringValue !== undefined) {
+            return { sv: sharedStringValue };
+        }
+        return getCellUserEnteredValue(cellData);
+    }, [getCellData, getSharedStringValue]);
+    /**
+     * Get error value of a cell
+     */
+    var getErrorValue = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        var effectiveValue = getCellEffectiveValue(cellData);
+        return getExtendedValueError(effectiveValue);
+    }, [getCellData]);
+    /**
+     * Return structured value for calculation
+     */
+    var getEffectiveValueForCalculation = useCallbackRef(useCallback(function (sheetId, rowIndex, columnIndex, property) {
+        var _a, _b, _c, _d;
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        // User us always accessing a structured value
+        if (property) {
+            return getEffectiveStructuredValueRef === null || getEffectiveStructuredValueRef === void 0 ? void 0 : getEffectiveStructuredValueRef((_a = getCellEffectiveValue(getCellData(sheetId, rowIndex, columnIndex))) === null || _a === void 0 ? void 0 : _a.structuredValue, property);
+        }
+        // Check if error value - but skip validation errors (type: "Invalid")
+        // Validation errors are visual indicators only and should not affect formulas
+        var effectiveValue = getCellEffectiveValue(cellData);
+        var errorValue = getExtendedValueError(effectiveValue);
+        if (errorValue && errorValue.type !== "Invalid") {
+            return new FormulaError(errorValue.name, errorValue.message);
+        }
+        var hyperlink = getHyperlinkText(getHyperLink(sheetId, rowIndex, columnIndex));
+        return ((_d = (_c = (_b = hyperlink !== null && hyperlink !== void 0 ? hyperlink : getEffectiveValue(sheetId, rowIndex, columnIndex)) !== null && _b !== void 0 ? _b : hyperlink) !== null && _c !== void 0 ? _c : getEffectiveStructuredValueRef === null || getEffectiveStructuredValueRef === void 0 ? void 0 : getEffectiveStructuredValueRef(effectiveValue === null || effectiveValue === void 0 ? void 0 : effectiveValue.structuredValue)) !== null && _d !== void 0 ? _d : effectiveValue === null || effectiveValue === void 0 ? void 0 : effectiveValue.structuredValue);
+    }, [
+        getCellData,
+        getEffectiveValue,
+        getHyperLink,
+        getEffectiveStructuredValueRef,
+    ]));
+    /**
+     * Resolve a formula cell's derived number format. Returns `undefined`
+     * for non-formula cells, when `uf.numberFormat` is set, or when no
+     * derivation is possible.
+     *
+     * Single-pass derivation from **direct** precedents only — no
+     * recursion, no transitive walk. When a precedent is itself a formula
+     * cell, its derived format is read from the per-cell LRU cache
+     * populated during an earlier `getDerivedFormat` call. The cache
+     * fingerprint `(value, precedentUfRefs)` invalidates this cell
+     * automatically whenever a direct precedent's format object identity
+     * changes — so a chain like `C1 = B1 = A1 = TODAY()` settles via
+     * normal cache invalidation: A1 derives DATE → B1's fingerprint sees
+     * the new DATE ref → B1 re-derives DATE → C1's fingerprint sees B1's
+     * new ref → C1 re-derives DATE. The renderer's row-major iteration
+     * naturally visits precedents before dependents in the common case,
+     * so this converges in a single render.
+     */
+    var getDerivedFormat = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var _a, _b, _c;
+        var rootCell = getCellData(sheetId, rowIndex, columnIndex);
+        if (!rootCell)
+            return undefined;
+        var rootFormula = getExtendedValueFormula(getCellUserEnteredValue(rootCell));
+        if (!rootFormula)
+            return undefined;
+        var resolveUf = function (cell) {
+            var _a, _b;
+            var uf = getCellUserEnteredFormat(cell);
+            return isStyleReference(uf)
+                ? (_a = cellXfs === null || cellXfs === void 0 ? void 0 : cellXfs.get(getStyleId(uf))) !== null && _a !== void 0 ? _a : undefined
+                : (_b = uf) !== null && _b !== void 0 ? _b : undefined;
+        };
+        if ((_a = resolveUf(rootCell)) === null || _a === void 0 ? void 0 : _a.numberFormat)
+            return undefined;
+        if (!getPrecedents || !sheetData)
+            return undefined;
+        // Look up a precedent's numberFormat without walking its chain.
+        // The LRU cache holds the last-rendered derived format for any
+        // formula cell we've previously processed; for plain cells (no
+        // formula) we read `uf.numberFormat` directly. If the cache entry
+        // is stale, the consumer's own fingerprint (built below) will
+        // detect it next render and re-derive.
+        var resolveNumberFormat = function (psId, pr, pc) {
+            var _a, _b, _c, _d, _e;
+            var cached = formulaNumberFormatCache.current.get(psId, pr, pc);
+            if (cached)
+                return cached.numberFormat;
+            var pCell = (_c = (_b = (_a = sheetData === null || sheetData === void 0 ? void 0 : sheetData[psId]) === null || _a === void 0 ? void 0 : _a[pr]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[pc];
+            if (!pCell)
+                return undefined;
+            return (_e = (_d = resolveUf(pCell)) === null || _d === void 0 ? void 0 : _d.numberFormat) !== null && _e !== void 0 ? _e : undefined;
+        };
+        var effectiveValue = getCellEffectiveValue(rootCell);
+        var currentValue = (_c = (_b = getExtendedValueNumber(effectiveValue)) !== null && _b !== void 0 ? _b : getExtendedValueString(effectiveValue)) !== null && _c !== void 0 ? _c : getExtendedValueBool(effectiveValue);
+        var directPrecedents = getPrecedents({
+            sheetId: sheetId,
+            rowIndex: rowIndex,
+            columnIndex: columnIndex,
+        });
+        var currentPrecedentFormatRefs = collectPrecedentFormatRefs(directPrecedents, sheetId, resolveNumberFormat);
+        var cached = formulaNumberFormatCache.current.get(sheetId, rowIndex, columnIndex);
+        if (cached &&
+            Object.is(cached.value, currentValue) &&
+            shallowArrayRefEqual(cached.precedentUfRefs, currentPrecedentFormatRefs)) {
+            return cached.format;
+        }
+        var derivedNumberFormat = deriveEffectiveNumberFormatFromPrecedents(rootFormula, directPrecedents, sheetData, tokenizer, sheetId, rowIndex, columnIndex, locale, getSheetId, cellXfsRegistry, getDataValidationById, typeof currentValue === "number" ? currentValue : null, resolveNumberFormat);
+        var numberFormat = derivedNumberFormat !== null && derivedNumberFormat !== void 0 ? derivedNumberFormat : undefined;
+        var format = numberFormat
+            ? { numberFormat: numberFormat }
+            : undefined;
+        formulaNumberFormatCache.current.set(sheetId, rowIndex, columnIndex, {
+            value: currentValue,
+            precedentUfRefs: currentPrecedentFormatRefs,
+            numberFormat: numberFormat,
+            format: format,
+        });
+        return format;
+    }, [
+        getCellData,
+        cellXfs,
+        cellXfsRegistry,
+        getDataValidationById,
+        getPrecedents,
+        sheetData,
+        tokenizer,
+        locale,
+        getSheetId,
+    ]);
+    /**
+     * Resolve the rendered cell format: user-entered layer (style-ref-resolved
+     * via `cellXfs`) merged with the precedent-derived `numberFormat` for
+     * formula cells. Returns the user format alone for non-formula cells, or
+     * when an explicit `uf.numberFormat` already wins (`getDerivedFormat`
+     * short-circuits in that case).
+     *
+     * Plain `useCallback` — `libs/grid` invokes this via the cellRenderer
+     * **during** its `cells` useMemo (render phase). A `useCallbackRef`
+     * wrapper updates its internal ref in `useLayoutEffect` (post-commit),
+     * so during-render calls would read the previous render's closure — and
+     * miss fresh `sheetData`. That caused precedent-derived format updates
+     * (e.g. A1 → currency propagating to B1 = SUM(A1, 4)) to lag by a render.
+     * With `useCallback`, identity churns when `sheetData` / deps change,
+     * which is exactly the repaint signal the downstream memos need.
+     * Per-cell merged-result identity is still preserved by the (eff, der)
+     * WeakMap cache below.
+     */
+    var getEffectiveFormat = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var eff;
+        if (cellStyles) {
+            // Engine-authoritative styles: the map is the SOLE source of a cell's user format. A missing
+            // entry means "no format" (so an undo that clears the entry actually clears the cell) — we
+            // intentionally do NOT fall back to the cell's own `uf`/`cellXfs` here.
+            eff = cellStyles.get("".concat(sheetId, "!").concat(cellToAddress({ rowIndex: rowIndex, columnIndex: columnIndex }, false, false)));
+        }
+        else {
+            var cellData = getCellData(sheetId, rowIndex, columnIndex);
+            var userEnteredFormat = getCellUserEnteredFormat(cellData);
+            eff = isStyleReference(userEnteredFormat)
+                ? cellXfs === null || cellXfs === void 0 ? void 0 : cellXfs.get(getStyleId(userEnteredFormat))
+                : userEnteredFormat;
+        }
+        var der = getDerivedFormat(sheetId, rowIndex, columnIndex);
+        if (!der)
+            return eff;
+        if (!eff)
+            return der;
+        var inner = mergedFormatCache.current.get(eff);
+        if (!inner) {
+            inner = new WeakMap();
+            mergedFormatCache.current.set(eff, inner);
+        }
+        var merged = inner.get(der);
+        if (!merged) {
+            merged = __assign(__assign({}, eff), der);
+            inner.set(der, merged);
+        }
+        return merged;
+    }, [getCellData, getDerivedFormat, cellStyles, cellXfs]);
+    /**
+     * Get formula value entered by user
+     */
+    var getFormulaValue = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        if (!cellData)
+            return undefined;
+        var userEnteredValue = getCellUserEnteredValue(cellData);
+        if (!userEnteredValue)
+            return undefined;
+        return getExtendedValueFormula(userEnteredValue);
+    }, [getCellData]);
+    /**
+     * Get formatted value.
+     *
+     * Non-formula cells: read persisted `fv` (set at write time).
+     * Formula cells with a structured value: read `effectiveValue.structuredValue`.
+     * Scalar formula cells: derive via `createFormattedValue(value, type, pattern, locale)`,
+     * memoised by `(locale, pattern, value)` since many formula cells share
+     * the same tuple.
+     */
+    var getFormattedValue = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        // Check for shared strings
+        var sharedStringValue = getSharedStringValue(cellData);
+        if (sharedStringValue !== undefined) {
+            // Excel display parity: a lone text-prefix apostrophe (`'`) renders
+            // as a blank cell — the `'` stays visible only in the formula bar.
+            return sharedStringValue === "'" ? "" : sharedStringValue;
+        }
+        var userEnteredValue = getCellUserEnteredValue(cellData);
+        var formula = getExtendedValueFormula(userEnteredValue);
+        if (!formula) {
+            // Excel display parity: a user-entered lone text-prefix apostrophe
+            // (`'`) renders as a blank cell (the formula bar still shows the `'`).
+            if (getExtendedValueString(userEnteredValue) === "'") {
+                return "";
+            }
+            return getCellFormattedValue(cellData);
+        }
+        // Formula cells normally derive their display string from
+        // effectiveValue + uf at render time, ignoring any persisted `fv`.
+        // While a recalc is in flight calc-begin pins `fv = "Loading..."`
+        // on the cellData; honor that placeholder here so the renderer
+        // surfaces the loading indicator instead of the stale ev value.
+        var persistedFormattedValue = getCellFormattedValue(cellData);
+        if (persistedFormattedValue === LOADING_VALUE) {
+            return persistedFormattedValue;
+        }
+        // Formula cells from this point on
+        var effectiveValue = getCellEffectiveValue(cellData);
+        var structured = effectiveValue === null || effectiveValue === void 0 ? void 0 : effectiveValue.structuredValue;
+        if (structured) {
+            switch (structured.kind) {
+                case "hyperlink":
+                    return (_a = structured.title) !== null && _a !== void 0 ? _a : structured.url;
+                case "image":
+                    return "";
+                case "sparkline":
+                default:
+                    return structured.formattedValue;
+            }
+        }
+        var errorValue = getExtendedValueError(effectiveValue);
+        if (errorValue) {
+            return (_b = errorValue.name) !== null && _b !== void 0 ? _b : "#ERROR!";
+        }
+        var value = (_d = (_c = getExtendedValueNumber(effectiveValue)) !== null && _c !== void 0 ? _c : getExtendedValueString(effectiveValue)) !== null && _d !== void 0 ? _d : getExtendedValueBool(effectiveValue);
+        if (isNil(value)) {
+            return undefined;
+        }
+        var uf = getEffectiveFormat(sheetId, rowIndex, columnIndex);
+        var pattern = (_f = (_e = uf === null || uf === void 0 ? void 0 : uf.numberFormat) === null || _e === void 0 ? void 0 : _e.pattern) !== null && _f !== void 0 ? _f : "General";
+        var valueType = (_g = detectValueType(value, locale, lenientGrouping)) !== null && _g !== void 0 ? _g : "stringValue";
+        var cacheLocale = locale !== null && locale !== void 0 ? locale : getCurrentLocale();
+        var cached = formulaFormattedValueCache.current.get(cacheLocale, pattern, valueType, value);
+        if (cached !== undefined) {
+            return cached;
+        }
+        var formatted = createFormattedValue(value, valueType, pattern, locale);
+        if (formatted !== undefined) {
+            formulaFormattedValueCache.current.set(cacheLocale, pattern, valueType, value, formatted);
+        }
+        return formatted;
+    }, [
+        getCellData,
+        getSharedStringValue,
+        getEffectiveFormat,
+        locale,
+        lenientGrouping,
+    ]);
+    /**
+     * Get value entered by the user in a cell
+     */
+    var getUserEnteredValue = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        var sharedStringValue = getSharedStringValue(cellData);
+        if (sharedStringValue !== undefined) {
+            return { sv: sharedStringValue };
+        }
+        return getCellUserEnteredValue(cellData);
+    }, [getCellData, getSharedStringValue]);
+    // Get user entered value of a cell
+    // Remove useCallbackRef as its being in FloatingCellEditor
+    var getUserEnteredStringValue = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var formulaValue = getFormulaValue(sheetId, rowIndex, columnIndex);
+        if (formulaValue && !protectFormulas) {
+            return formulaValue;
+        }
+        var userEnteredValue = getUserEnteredValue(sheetId, rowIndex, columnIndex);
+        var stringValue = getExtendedValueString(userEnteredValue);
+        if (stringValue) {
+            return stringValue;
+        }
+        return undefined;
+    }, [getUserEnteredValue, protectFormulas, getFormulaValue]);
+    // Stable reference for calculator
+    var getUserEnteredValueStable = useCallbackRef(getUserEnteredStringValue);
+    // Get the conditional format formula value
+    var getConditionalFormatFormula = useCallbackRef(useCallback(function (sheetId, rowIndex, columnIndex, conditionalFormatId) {
+        var e_5, _a;
+        var _b, _c, _d, _e, _f, _g, _h, _j;
+        var rule = conditionalFormatById.get(conditionalFormatId);
+        if (!rule) {
+            return undefined;
+        }
+        var formulaValue = isConditionalFormatFormulaRule(rule)
+            ? buildConditionalFormatExpression(rule, (_h = cellToAddress({
+                rowIndex: (_d = (_c = (_b = rule === null || rule === void 0 ? void 0 : rule.ranges) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.startRowIndex) !== null && _d !== void 0 ? _d : 1,
+                columnIndex: (_g = (_f = (_e = rule === null || rule === void 0 ? void 0 : rule.ranges) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.startColumnIndex) !== null && _g !== void 0 ? _g : 1,
+            }, false, false)) !== null && _h !== void 0 ? _h : "A1", locale)
+            : undefined;
+        if (rule.ranges.length && formulaValue) {
+            var masterCell = {
+                rowIndex: rule.ranges[0].startRowIndex,
+                columnIndex: rule.ranges[0].startColumnIndex,
+            };
+            var activeSheetName = (_j = getSheetName(sheetId)) !== null && _j !== void 0 ? _j : "";
+            try {
+                for (var _k = __values(rule.ranges), _l = _k.next(); !_l.done; _l = _k.next()) {
+                    var range = _l.value;
+                    if (sheetId === range.sheetId &&
+                        isCellWithinBounds({ rowIndex: rowIndex, columnIndex: columnIndex }, range)) {
+                        var newFormula = formulaToRelativeReference(formulaValue, masterCell, { rowIndex: rowIndex, columnIndex: columnIndex }, activeSheetName, { ignoreCircular: true, preserveAbsolutes: true });
+                        return newFormula;
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_l && !_l.done && (_a = _k.return)) _a.call(_k);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }, [conditionalFormatById, getSheetName]));
+    // Get getDataValidation formula value
+    var getDataValidationFormula = useCallbackRef(useCallback(function (sheetId, rowIndex, columnIndex) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        // Check if its a
+        var dataValidation = cellData === null || cellData === void 0 ? void 0 : cellData.dataValidation;
+        if (typeof dataValidation === "string" ||
+            typeof dataValidation === "number") {
+            dataValidation = getDataValidationById(dataValidation);
+        }
+        var formulaValue = isDataValidationFormulaRule(dataValidation)
+            ? buildDataValidationExpression(dataValidation, (_g = cellToAddress({
+                rowIndex: (_c = (_b = (_a = dataValidation === null || dataValidation === void 0 ? void 0 : dataValidation.ranges) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.startRowIndex) !== null && _c !== void 0 ? _c : 1,
+                columnIndex: (_f = (_e = (_d = dataValidation === null || dataValidation === void 0 ? void 0 : dataValidation.ranges) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.startColumnIndex) !== null && _f !== void 0 ? _f : 1,
+            }, false, false)) !== null && _g !== void 0 ? _g : "A1", locale)
+            : undefined;
+        if (formulaValue &&
+            dataValidation.ranges) {
+            var masterCell = {
+                rowIndex: dataValidation.ranges[0]
+                    .startRowIndex,
+                columnIndex: dataValidation.ranges[0]
+                    .startColumnIndex,
+            };
+            var activeSheetName = (_h = getSheetName(sheetId)) !== null && _h !== void 0 ? _h : "";
+            return ((_j = formulaToRelativeReference(formulaValue, masterCell, { rowIndex: rowIndex, columnIndex: columnIndex }, activeSheetName, { ignoreCircular: true, preserveAbsolutes: true })) !== null && _j !== void 0 ? _j : "");
+        }
+        return formulaValue;
+    }, [getCellData, getDataValidationById, getSheetName]));
+    // Get getDataValidation
+    var getDataValidation = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        // Check if its a
+        var dataValidation = cellData === null || cellData === void 0 ? void 0 : cellData.dataValidation;
+        if (typeof dataValidation === "string" ||
+            typeof dataValidation === "number") {
+            dataValidation = getDataValidationById(dataValidation);
+        }
+        return dataValidation;
+    }, [getCellData, getDataValidationById]);
+    // Get current sheet Id
+    var getActiveSheetId = useCallbackRef(useCallback(function () { return activeSheetId; }, [activeSheetId]));
+    // User entered format
+    var getUserEnteredFormat = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var cellData = getCellData(sheetId, rowIndex, columnIndex);
+        if (!cellData)
+            return undefined;
+        return getCellUserEnteredFormat(cellData);
+    }, [getCellData]);
+    // Useful for charts, get series data values
+    // Do not use useCallbackRef, so charts can update
+    // when columns and rows are hidden
+    var getSeriesValuesFromRange = useCallback(function (sheetRange, hiddenDimensionStategy) {
+        var e_6, _a;
+        if (hiddenDimensionStategy === void 0) { hiddenDimensionStategy = "SKIP_HIDDEN_ROWS_AND_COLUMNS"; }
+        var effectiveValues = [];
+        var sheetId = sheetRange.sheetId;
+        var startRowIndex = sheetRange.startRowIndex, startColumnIndex = sheetRange.startColumnIndex, endRowIndex = sheetRange.endRowIndex, endColumnIndex = sheetRange.endColumnIndex;
+        try {
+            for (var _b = __values(iterateCells(startRowIndex, endColumnIndex, endRowIndex, startColumnIndex)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                if (hiddenDimensionStategy === "SKIP_HIDDEN_ROWS_AND_COLUMNS" &&
+                    (isHiddenRow(sheetId, rowIndex) ||
+                        isColumnHidden(sheetId, columnIndex))) {
+                    continue;
+                }
+                var effectiveValue = getEffectiveValue(sheetId, rowIndex, columnIndex);
+                effectiveValues.push(effectiveValue);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        return effectiveValues;
+    }, [getEffectiveValue, isColumnHidden, isHiddenRow]);
+    // Useful for charts, get domain values
+    // Do not use useCallbackRef, so charts can update
+    // when columns and rows are hidden
+    var getDomainValuesFromRange = useCallback(function (sheetRange, hiddenDimensionStategy) {
+        var e_7, _a;
+        if (hiddenDimensionStategy === void 0) { hiddenDimensionStategy = "SKIP_HIDDEN_ROWS_AND_COLUMNS"; }
+        var formattedValues = [];
+        var sheetId = sheetRange.sheetId;
+        var startRowIndex = sheetRange.startRowIndex, startColumnIndex = sheetRange.startColumnIndex, endRowIndex = sheetRange.endRowIndex, endColumnIndex = sheetRange.endColumnIndex;
+        try {
+            for (var _b = __values(iterateCells(startRowIndex, endColumnIndex, endRowIndex, startColumnIndex)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                if (hiddenDimensionStategy === "SKIP_HIDDEN_ROWS_AND_COLUMNS" &&
+                    (isHiddenRow(sheetId, rowIndex) ||
+                        isColumnHidden(sheetId, columnIndex))) {
+                    continue;
+                }
+                var formattedValue = getFormattedValue(sheetId, rowIndex, columnIndex);
+                formattedValues.push(formattedValue);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return formattedValues;
+    }, [isHiddenRow, isColumnHidden, getFormattedValue]);
+    // Get formatting information from a range
+    var getFormattingFromRange = useCallback(function (sheetRange, hiddenDimensionStategy) {
+        var e_8, _a;
+        if (hiddenDimensionStategy === void 0) { hiddenDimensionStategy = "SKIP_HIDDEN_ROWS_AND_COLUMNS"; }
+        var formattingValues = [];
+        var sheetId = sheetRange.sheetId;
+        var startRowIndex = sheetRange.startRowIndex, startColumnIndex = sheetRange.startColumnIndex, endRowIndex = sheetRange.endRowIndex, endColumnIndex = sheetRange.endColumnIndex;
+        try {
+            for (var _b = __values(iterateCells(startRowIndex, endColumnIndex, endRowIndex, startColumnIndex)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                if (hiddenDimensionStategy === "SKIP_HIDDEN_ROWS_AND_COLUMNS" &&
+                    (isHiddenRow(sheetId, rowIndex) ||
+                        isColumnHidden(sheetId, columnIndex))) {
+                    continue;
+                }
+                // Return the rendered format consumers actually see (auto-derived
+                // bits, formula precedent format, CF overlay) — NOT raw `ef` which
+                // is no longer persisted on cellData.
+                var effectiveFormat = getEffectiveFormat(sheetId, rowIndex, columnIndex);
+                formattingValues.push(effectiveFormat);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        return formattingValues;
+    }, [isHiddenRow, isColumnHidden, getEffectiveFormat]);
+    // Get user entered values from a range
+    var getUserEnteredValuesFromRange = useCallback(function (sheetRange, hiddenDimensionStategy) {
+        var e_9, _a;
+        if (hiddenDimensionStategy === void 0) { hiddenDimensionStategy = "SKIP_HIDDEN_ROWS_AND_COLUMNS"; }
+        var userEnteredValues = [];
+        var sheetId = sheetRange.sheetId;
+        var startRowIndex = sheetRange.startRowIndex, startColumnIndex = sheetRange.startColumnIndex, endRowIndex = sheetRange.endRowIndex, endColumnIndex = sheetRange.endColumnIndex;
+        try {
+            for (var _b = __values(iterateCells(startRowIndex, endColumnIndex, endRowIndex, startColumnIndex)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                if (hiddenDimensionStategy === "SKIP_HIDDEN_ROWS_AND_COLUMNS" &&
+                    (isHiddenRow(sheetId, rowIndex) ||
+                        isColumnHidden(sheetId, columnIndex))) {
+                    continue;
+                }
+                var userEnteredValue = getUserEnteredStringValue(sheetId, rowIndex, columnIndex);
+                userEnteredValues.push(userEnteredValue);
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        return userEnteredValues;
+    }, [getUserEnteredStringValue, isColumnHidden, isHiddenRow]);
+    // Get user entered values from a range
+    var getFormulasFromRange = useCallback(function (sheetRange, hiddenDimensionStategy) {
+        var e_10, _a;
+        if (hiddenDimensionStategy === void 0) { hiddenDimensionStategy = "SKIP_HIDDEN_ROWS_AND_COLUMNS"; }
+        var formulas = [];
+        var sheetId = sheetRange.sheetId;
+        var startRowIndex = sheetRange.startRowIndex, startColumnIndex = sheetRange.startColumnIndex, endRowIndex = sheetRange.endRowIndex, endColumnIndex = sheetRange.endColumnIndex;
+        try {
+            for (var _b = __values(iterateCells(startRowIndex, endColumnIndex, endRowIndex, startColumnIndex)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                if (hiddenDimensionStategy === "SKIP_HIDDEN_ROWS_AND_COLUMNS" &&
+                    (isHiddenRow(sheetId, rowIndex) ||
+                        isColumnHidden(sheetId, columnIndex))) {
+                    continue;
+                }
+                var formula = getFormulaValue(sheetId, rowIndex, columnIndex);
+                formulas.push(formula);
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        return formulas;
+    }, [getFormulaValue, isColumnHidden, isHiddenRow]);
+    // Get array of records from a given range
+    var getColumnarDataFromRange = useCallbackRef(useCallback(function (sheetRange) {
+        var _a;
+        var columnarData = {};
+        for (var columnIndex = sheetRange.startColumnIndex; columnIndex <= sheetRange.endColumnIndex; columnIndex++) {
+            var columnName = getFormattedValue(sheetRange.sheetId, sheetRange.startRowIndex, columnIndex);
+            if (!isNil(columnName)) {
+                columnarData[columnName] = [];
+            }
+            for (var rowIndex = sheetRange.startRowIndex; rowIndex <= sheetRange.endRowIndex; rowIndex++) {
+                if (rowIndex === sheetRange.startRowIndex) {
+                    continue;
+                }
+                var fieldValue = (_a = getEffectiveValue(sheetRange.sheetId, rowIndex, columnIndex)) !== null && _a !== void 0 ? _a : "";
+                if (!isNil(columnName)) {
+                    columnarData[columnName].push(fieldValue);
+                }
+            }
+        }
+        return columnarData;
+    }, [getEffectiveValue, getFormattedValue]));
+    return {
+        getDataRowCount: getDataRowCount,
+        getNonEmptyRowCount: getNonEmptyRowCount,
+        getNonEmptyColumnCount: getNonEmptyColumnCount,
+        getSheetId: getSheetId,
+        getSheetName: getSheetName,
+        getSheetCount: getSheetCount,
+        getSheetIndex: getSheetIndex,
+        getSheetProperties: getSheetProperties,
+        getCellData: getCellData,
+        getMentionsFromCell: getMentionsFromCell,
+        getTextFormatRuns: getTextFormatRuns,
+        getUserEnteredValue: getUserEnteredStringValue,
+        getUserEnteredValueStable: getUserEnteredValueStable,
+        getConditionalFormatFormula: getConditionalFormatFormula,
+        getDataValidationFormula: getDataValidationFormula,
+        getErrorValue: getErrorValue,
+        getEffectiveValue: getEffectiveValue,
+        getEffectiveValueForCalculation: getEffectiveValueForCalculation,
+        getFormattedValue: getFormattedValue,
+        getEffectiveFormat: getEffectiveFormat,
+        getActiveSheetId: getActiveSheetId,
+        getUserEnteredFormat: getUserEnteredFormat,
+        getSeriesValuesFromRange: getSeriesValuesFromRange,
+        getDomainValuesFromRange: getDomainValuesFromRange,
+        getColumnarDataFromRange: getColumnarDataFromRange,
+        getUserEnteredValuesFromRange: getUserEnteredValuesFromRange,
+        getFormattingFromRange: getFormattingFromRange,
+        getFormulasFromRange: getFormulasFromRange,
+        isHiddenRow: isHiddenRow,
+        isHiddenByFilterRow: isHiddenByFilterRow,
+        getSheetRowCount: getSheetRowCount,
+        getSheetColumnCount: getSheetColumnCount,
+        getColumnWidth: getColumnWidth,
+        getRowHeight: getRowHeight,
+        isColumnHidden: isColumnHidden,
+        isRowResizedByUser: isRowResizedByUser,
+        getDataColumnCount: getDataColumnCount,
+        getActualRowCount: getActualRowCount,
+        getFrozenRowCount: getFrozenRowCount,
+        getDataValidation: getDataValidation,
+        getDataValidationById: getDataValidationById,
+        getConditionalFormattingById: getConditionalFormattingById,
+        getEffectiveExtendedValue: getEffectiveExtendedValue,
+        getUserEnteredExtendedValue: getUserEnteredExtendedValue,
+    };
+};