@rowsncolumns/spreadsheet 10.2.68

package/dist/cjs/hooks/use-conditional-formatting.js

@@ -0,0 +1,720 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConditionalFormatting = void 0;
+var tslib_1 = require("tslib");
+var grid_1 = require("@rowsncolumns/grid");
+var utils_1 = require("@rowsncolumns/utils");
+var isNil_1 = tslib_1.__importDefault(require("lodash/isNil"));
+var react_1 = require("react");
+var cf_overlays_1 = require("../api/cf-overlays");
+var cf_engine_1 = require("../api/cf-engine");
+var cf_window_1 = require("../api/cf-window");
+var heatmap_1 = require("../api/heatmap");
+var validation_1 = require("../api/validation");
+var themes_1 = require("../themes");
+var config_1 = require("../config");
+var useConditionalFormatting = function (_a) {
+    var sheetId = _a.sheetId, theme = _a.theme, conditionalFormats = _a.conditionalFormats, locale = _a.locale, getValidationValue = _a.getValidationValue, isNumberValue = _a.isNumberValue, getSheetRowCount = _a.getSheetRowCount, getSheetColumnCount = _a.getSheetColumnCount, evaluationWindow = _a.window, getConditionalFormatResult = _a.getConditionalFormatResult;
+    var previousEffectiveValueMap = (0, react_1.useRef)(undefined);
+    // Lazy initialization
+    var getPreviousValueMap = (0, react_1.useCallback)(function () {
+        if (!previousEffectiveValueMap.current) {
+            previousEffectiveValueMap.current = new Map();
+        }
+        return previousEffectiveValueMap.current;
+    }, []);
+    // Set previous value
+    var setPreviousValue = (0, react_1.useCallback)(function (rowIndex, columnIndex, conditionIndex, effectiveValue) {
+        getPreviousValueMap().set("".concat((0, grid_1.cellIdentifier)(rowIndex, columnIndex), "_").concat(conditionIndex), effectiveValue);
+    }, [getPreviousValueMap]);
+    // Get previous value
+    var getPreviousValue = (0, react_1.useCallback)(function (rowIndex, columnIndex, conditionIndex) {
+        return getPreviousValueMap().get("".concat((0, grid_1.cellIdentifier)(rowIndex, columnIndex), "_").concat(conditionIndex));
+    }, [getPreviousValueMap]);
+    // Helper to clamp range to actual sheet dimensions. Ranges are 1-based inclusive
+    // (data rows/columns are 1..count; index 0 is the header), so the last valid index
+    // is the count itself — a full-column selection legitimately ends at
+    // endRowIndex === rowCount, and clamping to count - 1 silently dropped the final
+    // row/column of full-height/width rules.
+    var clampRange = (0, react_1.useCallback)(function (range) {
+        var _a, _b;
+        var rowCount = (_a = getSheetRowCount === null || getSheetRowCount === void 0 ? void 0 : getSheetRowCount(range.sheetId)) !== null && _a !== void 0 ? _a : config_1.DEFAULT_ROW_COUNT;
+        var columnCount = (_b = getSheetColumnCount === null || getSheetColumnCount === void 0 ? void 0 : getSheetColumnCount(range.sheetId)) !== null && _b !== void 0 ? _b : config_1.DEFAULT_COLUMN_COUNT;
+        return tslib_1.__assign(tslib_1.__assign({}, range), { endRowIndex: Math.min(range.endRowIndex, rowCount), endColumnIndex: Math.min(range.endColumnIndex, columnCount) });
+    }, [getSheetRowCount, getSheetColumnCount]);
+    return (0, react_1.useMemo)(function () {
+        var e_1, _a;
+        var _b, _c, _d, _e, _f, _g;
+        var formattingByCell = new Map();
+        if (!conditionalFormats) {
+            return formattingByCell;
+        }
+        var sortedRules = conditionalFormats
+            .map(function (rule, index) { return ({ rule: rule, index: index }); })
+            .sort(function (left, right) {
+            var _a, _b;
+            var leftPriority = (_a = left.rule.priority) !== null && _a !== void 0 ? _a : Number.POSITIVE_INFINITY;
+            var rightPriority = (_b = right.rule.priority) !== null && _b !== void 0 ? _b : Number.POSITIVE_INFINITY;
+            if (leftPriority === rightPriority) {
+                return left.index - right.index;
+            }
+            return leftPriority - rightPriority;
+        })
+            .map(function (_a) {
+            var rule = _a.rule;
+            return rule;
+        });
+        var rules = evaluationWindow
+            ? (0, cf_window_1.windowConditionalFormatRules)({
+                rules: sortedRules,
+                sheetId: sheetId,
+                window: evaluationWindow,
+            })
+            : sortedRules;
+        // Aggregate rules the engine stamped per-cell results for. Judged on the
+        // ORIGINAL (pre-windowing) ranges: windowed ranges under-count coverage,
+        // and an over-cap rule (which the engine skipped) must keep computing.
+        var engineStampedRuleIds = getConditionalFormatResult
+            ? new Set(sortedRules
+                .filter(cf_engine_1.isEngineEvaluatedAggregateRule)
+                .map(function (rule) { return rule.id; }))
+            : undefined;
+        var stopCells = new Set();
+        // Consume the engine's per-cell stamps for an aggregate rule over one
+        // (possibly window-intersected) range — cells outside the window aren't
+        // visible, and the stamps already carry the FULL-range aggregate result.
+        var applyEngineStamps = function (rule, range, format) {
+            var e_2, _a;
+            try {
+                for (var _b = tslib_1.__values((0, utils_1.iterateCellsInRange)(range)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = tslib_1.__read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                    if ((getConditionalFormatResult === null || getConditionalFormatResult === void 0 ? void 0 : getConditionalFormatResult(sheetId, rowIndex, columnIndex, rule.id)) !== true) {
+                        continue;
+                    }
+                    var cellId = (0, grid_1.cellIdentifier)(rowIndex, columnIndex);
+                    if (stopCells.has(cellId)) {
+                        continue;
+                    }
+                    formattingByCell.set(cellId, format);
+                    if (rule.stopIfTrue) {
+                        stopCells.add(cellId);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        };
+        // There can be conditions applied
+        // to the same range
+        // So to get previous value, we have to save it
+        // in a key based on condition index
+        var conditionIndex = 0;
+        var _loop_1 = function (rule) {
+            var e_3, _h, e_4, _j, e_5, _k, e_6, _l, e_7, _m, e_8, _o, e_9, _p, e_10, _q, e_11, _r, e_12, _s, e_13, _t, e_14, _u, e_15, _v, e_16, _w;
+            var engineStamped = (_b = engineStampedRuleIds === null || engineStampedRuleIds === void 0 ? void 0 : engineStampedRuleIds.has(rule.id)) !== null && _b !== void 0 ? _b : false;
+            var ranges = rule.ranges, enabled = rule.enabled, booleanRule = rule.booleanRule, gradientRule = rule.gradientRule, topBottomRule = rule.topBottomRule, distinctRule = rule.distinctRule, iconSetRule = rule.iconSetRule, dataBarRule = rule.dataBarRule;
+            // Only look for enabled rules
+            if (typeof enabled !== "undefined" && enabled === false) {
+                return "continue";
+            }
+            if (booleanRule) {
+                try {
+                    for (var ranges_1 = (e_3 = void 0, tslib_1.__values(ranges)), ranges_1_1 = ranges_1.next(); !ranges_1_1.done; ranges_1_1 = ranges_1.next()) {
+                        var range = ranges_1_1.value;
+                        // Only pick current sheet
+                        if ((range === null || range === void 0 ? void 0 : range.sheetId) !== sheetId) {
+                            continue;
+                        }
+                        // Clamp range to actual sheet dimensions
+                        var clampedRange = clampRange(range);
+                        var conditionType = (_c = booleanRule === null || booleanRule === void 0 ? void 0 : booleanRule.condition) === null || _c === void 0 ? void 0 : _c.type;
+                        var isAboveBelowAverage = conditionType === "NUMBER_ABOVE_AVERAGE" ||
+                            conditionType === "NUMBER_BELOW_AVERAGE";
+                        // Engine-stamped above/below-average: the engine compared every
+                        // covered cell against the FULL range's mean — consume the stamps.
+                        if (isAboveBelowAverage && engineStamped) {
+                            applyEngineStamps(rule, clampedRange, booleanRule.format);
+                            continue;
+                        }
+                        var averageValue = void 0;
+                        if (isAboveBelowAverage) {
+                            var numericValues = [];
+                            try {
+                                for (var _x = (e_4 = void 0, tslib_1.__values((0, utils_1.iterateCellsInRange)(clampedRange))), _y = _x.next(); !_y.done; _y = _x.next()) {
+                                    var _z = tslib_1.__read(_y.value, 2), rowIndex = _z[0], columnIndex = _z[1];
+                                    var value = getValidationValue(sheetId, rowIndex, columnIndex, rule);
+                                    if (!(0, isNil_1.default)(value) &&
+                                        isNumberValue(sheetId, rowIndex, columnIndex) &&
+                                        Number.isFinite(Number(value))) {
+                                        numericValues.push(Number(value));
+                                    }
+                                }
+                            }
+                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                            finally {
+                                try {
+                                    if (_y && !_y.done && (_j = _x.return)) _j.call(_x);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                            }
+                            if (numericValues.length) {
+                                averageValue =
+                                    numericValues.reduce(function (sum, entry) { return sum + entry; }, 0) /
+                                        numericValues.length;
+                            }
+                        }
+                        // Formula path vs sync path: see `isConditionalFormatFormulaRule`
+                        // in `libs/spreadsheet-state/api/conditional-format.ts` for the
+                        // routing policy and what stays sync (above-average, *_PREVIOUS,
+                        // calendar-relative dates, ERROR/NOT_ERROR, gradient/topBottom/distinct).
+                        var isFormulaRule = (0, utils_1.isConditionalFormatFormulaRule)(rule);
+                        var usePreviousValue = !isFormulaRule &&
+                            (0, validation_1.shouldUsePreviousValue)((_d = booleanRule === null || booleanRule === void 0 ? void 0 : booleanRule.condition) === null || _d === void 0 ? void 0 : _d.type);
+                        try {
+                            // Iterate all cells within this range
+                            for (var _0 = (e_5 = void 0, tslib_1.__values((0, utils_1.iterateCellsInRange)(clampedRange))), _1 = _0.next(); !_1.done; _1 = _0.next()) {
+                                var _2 = tslib_1.__read(_1.value, 2), rowIndex = _2[0], columnIndex = _2[1];
+                                var effectiveValue = getValidationValue(sheetId, rowIndex, columnIndex, rule);
+                                var satisfies = false;
+                                if (booleanRule === null || booleanRule === void 0 ? void 0 : booleanRule.condition) {
+                                    if (isAboveBelowAverage) {
+                                        if (averageValue !== undefined &&
+                                            !(0, isNil_1.default)(effectiveValue) &&
+                                            isNumberValue(sheetId, rowIndex, columnIndex)) {
+                                            var numericValue = Number(effectiveValue);
+                                            if (Number.isFinite(numericValue)) {
+                                                satisfies =
+                                                    conditionType === "NUMBER_ABOVE_AVERAGE"
+                                                        ? numericValue > averageValue
+                                                        : numericValue < averageValue;
+                                            }
+                                        }
+                                    }
+                                    else if (isFormulaRule) {
+                                        satisfies = effectiveValue === true;
+                                    }
+                                    else {
+                                        satisfies = Boolean((0, validation_1.checkBooleanRule)(booleanRule, effectiveValue, usePreviousValue
+                                            ? getPreviousValue(rowIndex, columnIndex, conditionIndex)
+                                            : undefined, undefined, { locale: locale }));
+                                    }
+                                }
+                                if (satisfies) {
+                                    var cellId = (0, grid_1.cellIdentifier)(rowIndex, columnIndex);
+                                    if (stopCells.has(cellId)) {
+                                        continue;
+                                    }
+                                    formattingByCell.set(cellId, booleanRule.format);
+                                    if (rule.stopIfTrue) {
+                                        stopCells.add(cellId);
+                                    }
+                                }
+                                // Set previous value
+                                if (usePreviousValue) {
+                                    setPreviousValue(rowIndex, columnIndex, conditionIndex, effectiveValue);
+                                }
+                            }
+                        }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                        finally {
+                            try {
+                                if (_1 && !_1.done && (_k = _0.return)) _k.call(_0);
+                            }
+                            finally { if (e_5) throw e_5.error; }
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (ranges_1_1 && !ranges_1_1.done && (_h = ranges_1.return)) _h.call(ranges_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+            else if (gradientRule) {
+                // Heatmap
+                var values = [];
+                try {
+                    // Get colors from all ranges initially
+                    for (var ranges_2 = (e_6 = void 0, tslib_1.__values(ranges)), ranges_2_1 = ranges_2.next(); !ranges_2_1.done; ranges_2_1 = ranges_2.next()) {
+                        var range = ranges_2_1.value;
+                        // Only pick current sheet
+                        if ((range === null || range === void 0 ? void 0 : range.sheetId) !== sheetId) {
+                            continue;
+                        }
+                        // Clamp range to actual sheet dimensions
+                        var clampedRange = clampRange(range);
+                        var rangeValues = [];
+                        for (var rowIndex = clampedRange.startRowIndex; rowIndex <= clampedRange.endRowIndex; rowIndex++) {
+                            var rowValues = [];
+                            for (var columnIndex = clampedRange.startColumnIndex; columnIndex <= clampedRange.endColumnIndex; columnIndex++) {
+                                var value = getValidationValue(range.sheetId, rowIndex, columnIndex, rule);
+                                // Only accept number
+                                if (!(0, isNil_1.default)(value) &&
+                                    isNumberValue(range.sheetId, rowIndex, columnIndex)) {
+                                    rowValues.push(Number(value));
+                                }
+                                else {
+                                    rowValues.push(undefined);
+                                }
+                            }
+                            rangeValues.push(rowValues);
+                        }
+                        values.push(rangeValues);
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (ranges_2_1 && !ranges_2_1.done && (_l = ranges_2.return)) _l.call(ranges_2);
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+                var colors = (0, heatmap_1.getGradientColors)(values, gradientRule, theme);
+                var rangeIndex = 0;
+                try {
+                    // Apply colors
+                    for (var ranges_3 = (e_7 = void 0, tslib_1.__values(ranges)), ranges_3_1 = ranges_3.next(); !ranges_3_1.done; ranges_3_1 = ranges_3.next()) {
+                        var range = ranges_3_1.value;
+                        // Only pick current sheet
+                        if (range.sheetId !== sheetId) {
+                            continue;
+                        }
+                        // Clamp range to actual sheet dimensions
+                        var clampedRange = clampRange(range);
+                        for (var rowIndex = clampedRange.startRowIndex; rowIndex <= clampedRange.endRowIndex; rowIndex++) {
+                            for (var columnIndex = clampedRange.startColumnIndex; columnIndex <= clampedRange.endColumnIndex; columnIndex++) {
+                                var backgroundColor = (_f = (_e = colors[rangeIndex]) === null || _e === void 0 ? void 0 : _e[rowIndex - clampedRange.startRowIndex]) === null || _f === void 0 ? void 0 : _f[columnIndex - clampedRange.startColumnIndex];
+                                var cellId = (0, grid_1.cellIdentifier)(rowIndex, columnIndex);
+                                if (stopCells.has(cellId)) {
+                                    continue;
+                                }
+                                if ((0, isNil_1.default)(backgroundColor)) {
+                                    continue;
+                                }
+                                formattingByCell.set(cellId, {
+                                    backgroundColor: backgroundColor,
+                                });
+                                if (rule.stopIfTrue) {
+                                    stopCells.add(cellId);
+                                }
+                            }
+                        }
+                        rangeIndex++;
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (ranges_3_1 && !ranges_3_1.done && (_m = ranges_3.return)) _m.call(ranges_3);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+            }
+            else if (topBottomRule) {
+                var _loop_2 = function (range) {
+                    var e_17, _11, e_18, _12;
+                    if (range.sheetId !== sheetId) {
+                        return "continue";
+                    }
+                    // Clamp range to actual sheet dimensions
+                    var clampedRange = clampRange(range);
+                    // Engine-stamped rank rule: the engine ranked the FULL range —
+                    // consume its per-cell stamps instead of ranking the loaded window.
+                    if (engineStamped) {
+                        applyEngineStamps(rule, clampedRange, topBottomRule.format);
+                        return "continue";
+                    }
+                    var numericCells = [];
+                    try {
+                        for (var _13 = (e_17 = void 0, tslib_1.__values((0, utils_1.iterateCellsInRange)(clampedRange))), _14 = _13.next(); !_14.done; _14 = _13.next()) {
+                            var _15 = tslib_1.__read(_14.value, 2), rowIndex = _15[0], columnIndex = _15[1];
+                            var value = getValidationValue(sheetId, rowIndex, columnIndex, rule);
+                            if (!(0, isNil_1.default)(value) &&
+                                isNumberValue(sheetId, rowIndex, columnIndex) &&
+                                Number.isFinite(Number(value))) {
+                                numericCells.push({
+                                    rowIndex: rowIndex,
+                                    columnIndex: columnIndex,
+                                    value: Number(value),
+                                });
+                            }
+                        }
+                    }
+                    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                    finally {
+                        try {
+                            if (_14 && !_14.done && (_11 = _13.return)) _11.call(_13);
+                        }
+                        finally { if (e_17) throw e_17.error; }
+                    }
+                    if (numericCells.length === 0) {
+                        return "continue";
+                    }
+                    var total = numericCells.length;
+                    var desiredRank = Math.min(total, Math.max(1, topBottomRule.isPercent
+                        ? Math.ceil((topBottomRule.rank / 100) * total)
+                        : topBottomRule.rank));
+                    var sorted = tslib_1.__spreadArray([], tslib_1.__read(numericCells), false).sort(function (a, b) {
+                        return topBottomRule.type === "TOP"
+                            ? b.value - a.value
+                            : a.value - b.value;
+                    });
+                    var thresholdValue = (_g = sorted[Math.min(desiredRank - 1, sorted.length - 1)]) === null || _g === void 0 ? void 0 : _g.value;
+                    if (thresholdValue === undefined) {
+                        return "continue";
+                    }
+                    var comparator = topBottomRule.type === "TOP"
+                        ? function (value) { return value >= thresholdValue; }
+                        : function (value) { return value <= thresholdValue; };
+                    try {
+                        for (var numericCells_1 = (e_18 = void 0, tslib_1.__values(numericCells)), numericCells_1_1 = numericCells_1.next(); !numericCells_1_1.done; numericCells_1_1 = numericCells_1.next()) {
+                            var cell = numericCells_1_1.value;
+                            if (comparator(cell.value)) {
+                                var cellId = (0, grid_1.cellIdentifier)(cell.rowIndex, cell.columnIndex);
+                                if (stopCells.has(cellId)) {
+                                    continue;
+                                }
+                                formattingByCell.set(cellId, topBottomRule.format);
+                                if (rule.stopIfTrue) {
+                                    stopCells.add(cellId);
+                                }
+                            }
+                        }
+                    }
+                    catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                    finally {
+                        try {
+                            if (numericCells_1_1 && !numericCells_1_1.done && (_12 = numericCells_1.return)) _12.call(numericCells_1);
+                        }
+                        finally { if (e_18) throw e_18.error; }
+                    }
+                };
+                try {
+                    for (var ranges_4 = (e_8 = void 0, tslib_1.__values(ranges)), ranges_4_1 = ranges_4.next(); !ranges_4_1.done; ranges_4_1 = ranges_4.next()) {
+                        var range = ranges_4_1.value;
+                        _loop_2(range);
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (ranges_4_1 && !ranges_4_1.done && (_o = ranges_4.return)) _o.call(ranges_4);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+            }
+            else if (distinctRule) {
+                try {
+                    for (var ranges_5 = (e_9 = void 0, tslib_1.__values(ranges)), ranges_5_1 = ranges_5.next(); !ranges_5_1.done; ranges_5_1 = ranges_5.next()) {
+                        var range = ranges_5_1.value;
+                        if (range.sheetId !== sheetId) {
+                            continue;
+                        }
+                        // Clamp range to actual sheet dimensions
+                        var clampedRange = clampRange(range);
+                        // Engine-stamped duplicate/unique rule: the engine counted the FULL
+                        // range's occurrences — consume its per-cell stamps.
+                        if (engineStamped) {
+                            applyEngineStamps(rule, clampedRange, distinctRule.format);
+                            continue;
+                        }
+                        var occurrences = new Map();
+                        try {
+                            for (var _3 = (e_10 = void 0, tslib_1.__values((0, utils_1.iterateCellsInRange)(clampedRange))), _4 = _3.next(); !_4.done; _4 = _3.next()) {
+                                var _5 = tslib_1.__read(_4.value, 2), rowIndex = _5[0], columnIndex = _5[1];
+                                var value = getValidationValue(sheetId, rowIndex, columnIndex, rule);
+                                if ((0, isNil_1.default)(value)) {
+                                    continue;
+                                }
+                                var key = typeof value === "string"
+                                    ? value
+                                    : typeof value === "number" || typeof value === "boolean"
+                                        ? String(value)
+                                        : JSON.stringify(value);
+                                if (!occurrences.has(key)) {
+                                    occurrences.set(key, []);
+                                }
+                                occurrences.get(key).push({ rowIndex: rowIndex, columnIndex: columnIndex });
+                            }
+                        }
+                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                        finally {
+                            try {
+                                if (_4 && !_4.done && (_q = _3.return)) _q.call(_3);
+                            }
+                            finally { if (e_10) throw e_10.error; }
+                        }
+                        var shouldFormat = function (count) {
+                            return distinctRule.type === "DUPLICATE" ? count > 1 : count === 1;
+                        };
+                        try {
+                            for (var _6 = (e_11 = void 0, tslib_1.__values(occurrences.values())), _7 = _6.next(); !_7.done; _7 = _6.next()) {
+                                var cells = _7.value;
+                                if (!shouldFormat(cells.length)) {
+                                    continue;
+                                }
+                                try {
+                                    for (var cells_1 = (e_12 = void 0, tslib_1.__values(cells)), cells_1_1 = cells_1.next(); !cells_1_1.done; cells_1_1 = cells_1.next()) {
+                                        var cell = cells_1_1.value;
+                                        var cellId = (0, grid_1.cellIdentifier)(cell.rowIndex, cell.columnIndex);
+                                        if (stopCells.has(cellId)) {
+                                            continue;
+                                        }
+                                        formattingByCell.set(cellId, distinctRule.format);
+                                        if (rule.stopIfTrue) {
+                                            stopCells.add(cellId);
+                                        }
+                                    }
+                                }
+                                catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                                finally {
+                                    try {
+                                        if (cells_1_1 && !cells_1_1.done && (_s = cells_1.return)) _s.call(cells_1);
+                                    }
+                                    finally { if (e_12) throw e_12.error; }
+                                }
+                            }
+                        }
+                        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                        finally {
+                            try {
+                                if (_7 && !_7.done && (_r = _6.return)) _r.call(_6);
+                            }
+                            finally { if (e_11) throw e_11.error; }
+                        }
+                    }
+                }
+                catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                finally {
+                    try {
+                        if (ranges_5_1 && !ranges_5_1.done && (_p = ranges_5.return)) _p.call(ranges_5);
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                }
+            }
+            else if (iconSetRule) {
+                var glyphs = cf_overlays_1.ICON_SET_GLYPHS[iconSetRule.iconSet];
+                if (!glyphs) {
+                    conditionIndex++;
+                    return "continue";
+                }
+                var orderedGlyphs = iconSetRule.reverse
+                    ? tslib_1.__spreadArray([], tslib_1.__read(glyphs), false).reverse()
+                    : glyphs;
+                var orderedColors = iconSetRule.reverse
+                    ? tslib_1.__spreadArray([], tslib_1.__read(cf_overlays_1.ICON_SET_COLORS[iconSetRule.iconSet]), false).reverse()
+                    : cf_overlays_1.ICON_SET_COLORS[iconSetRule.iconSet];
+                var _loop_3 = function (range) {
+                    var e_19, _16, e_20, _17;
+                    if (range.sheetId !== sheetId)
+                        return "continue";
+                    var clampedRange = clampRange(range);
+                    // Aggregate range min/max for PERCENT/PERCENTILE threshold resolution.
+                    var rangeMin = Infinity;
+                    var rangeMax = -Infinity;
+                    var cellValues = [];
+                    try {
+                        for (var _18 = (e_19 = void 0, tslib_1.__values((0, utils_1.iterateCellsInRange)(clampedRange))), _19 = _18.next(); !_19.done; _19 = _18.next()) {
+                            var _20 = tslib_1.__read(_19.value, 2), rowIndex = _20[0], columnIndex = _20[1];
+                            var v = getValidationValue(sheetId, rowIndex, columnIndex, rule);
+                            if (!(0, isNil_1.default)(v) &&
+                                isNumberValue(sheetId, rowIndex, columnIndex) &&
+                                Number.isFinite(Number(v))) {
+                                var num = Number(v);
+                                cellValues.push({ rowIndex: rowIndex, columnIndex: columnIndex, value: num });
+                                if (num < rangeMin)
+                                    rangeMin = num;
+                                if (num > rangeMax)
+                                    rangeMax = num;
+                            }
+                        }
+                    }
+                    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+                    finally {
+                        try {
+                            if (_19 && !_19.done && (_16 = _18.return)) _16.call(_18);
+                        }
+                        finally { if (e_19) throw e_19.error; }
+                    }
+                    if (cellValues.length === 0)
+                        return "continue";
+                    var sortedThresholds = iconSetRule.thresholds
+                        .map(function (t) { return (0, cf_overlays_1.resolveThreshold)(t, rangeMin, rangeMax); })
+                        .filter(function (n) { return Number.isFinite(n); })
+                        .sort(function (a, b) { return a - b; });
+                    try {
+                        for (var cellValues_2 = (e_20 = void 0, tslib_1.__values(cellValues)), cellValues_2_1 = cellValues_2.next(); !cellValues_2_1.done; cellValues_2_1 = cellValues_2.next()) {
+                            var cell = cellValues_2_1.value;
+                            var bucket = (0, cf_overlays_1.pickIconBucket)(cell.value, sortedThresholds);
+                            var cellId = (0, grid_1.cellIdentifier)(cell.rowIndex, cell.columnIndex);
+                            if (stopCells.has(cellId))
+                                continue;
+                            var glyphIndex = Math.min(bucket, orderedGlyphs.length - 1);
+                            var glyph = orderedGlyphs[glyphIndex];
+                            var color = orderedColors[Math.min(bucket, orderedColors.length - 1)];
+                            var existing = formattingByCell.get(cellId);
+                            formattingByCell.set(cellId, tslib_1.__assign(tslib_1.__assign({}, (existing !== null && existing !== void 0 ? existing : {})), { 
+                                // iconSet + iconId are needed by the icon column filter to
+                                // match cells against a specific (iconSet, iconId) target.
+                                // They're harmless to renderers that only read `glyph`.
+                                conditionalIcon: {
+                                    glyph: glyph,
+                                    color: color,
+                                    iconSet: iconSetRule.iconSet,
+                                    iconId: glyphIndex,
+                                } }));
+                            if (rule.stopIfTrue)
+                                stopCells.add(cellId);
+                        }
+                    }
+                    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                    finally {
+                        try {
+                            if (cellValues_2_1 && !cellValues_2_1.done && (_17 = cellValues_2.return)) _17.call(cellValues_2);
+                        }
+                        finally { if (e_20) throw e_20.error; }
+                    }
+                };
+                try {
+                    for (var ranges_6 = (e_13 = void 0, tslib_1.__values(ranges)), ranges_6_1 = ranges_6.next(); !ranges_6_1.done; ranges_6_1 = ranges_6.next()) {
+                        var range = ranges_6_1.value;
+                        _loop_3(range);
+                    }
+                }
+                catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                finally {
+                    try {
+                        if (ranges_6_1 && !ranges_6_1.done && (_t = ranges_6.return)) _t.call(ranges_6);
+                    }
+                    finally { if (e_13) throw e_13.error; }
+                }
+            }
+            else if (dataBarRule) {
+                var barColor = (0, themes_1.getStringifiedColor)(dataBarRule.color, theme);
+                var negativeColor = dataBarRule.negativeColor
+                    ? (0, themes_1.getStringifiedColor)(dataBarRule.negativeColor, theme)
+                    : undefined;
+                var borderColor = dataBarRule.borderColor
+                    ? (0, themes_1.getStringifiedColor)(dataBarRule.borderColor, theme)
+                    : undefined;
+                var direction = dataBarRule.direction === "rightToLeft"
+                    ? "rightToLeft"
+                    : "leftToRight";
+                try {
+                    for (var ranges_7 = (e_14 = void 0, tslib_1.__values(ranges)), ranges_7_1 = ranges_7.next(); !ranges_7_1.done; ranges_7_1 = ranges_7.next()) {
+                        var range = ranges_7_1.value;
+                        if (range.sheetId !== sheetId)
+                            continue;
+                        var clampedRange = clampRange(range);
+                        var rangeMin = Infinity;
+                        var rangeMax = -Infinity;
+                        var cellValues = [];
+                        try {
+                            for (var _8 = (e_15 = void 0, tslib_1.__values((0, utils_1.iterateCellsInRange)(clampedRange))), _9 = _8.next(); !_9.done; _9 = _8.next()) {
+                                var _10 = tslib_1.__read(_9.value, 2), rowIndex = _10[0], columnIndex = _10[1];
+                                var v = getValidationValue(sheetId, rowIndex, columnIndex, rule);
+                                if (!(0, isNil_1.default)(v) &&
+                                    isNumberValue(sheetId, rowIndex, columnIndex) &&
+                                    Number.isFinite(Number(v))) {
+                                    var num = Number(v);
+                                    cellValues.push({ rowIndex: rowIndex, columnIndex: columnIndex, value: num });
+                                    if (num < rangeMin)
+                                        rangeMin = num;
+                                    if (num > rangeMax)
+                                        rangeMax = num;
+                                }
+                            }
+                        }
+                        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                        finally {
+                            try {
+                                if (_9 && !_9.done && (_v = _8.return)) _v.call(_8);
+                            }
+                            finally { if (e_15) throw e_15.error; }
+                        }
+                        if (cellValues.length === 0)
+                            continue;
+                        var min = (0, cf_overlays_1.resolveThreshold)(dataBarRule.minpoint, rangeMin, rangeMax);
+                        var max = (0, cf_overlays_1.resolveThreshold)(dataBarRule.maxpoint, rangeMin, rangeMax);
+                        var resolvedMin = Number.isFinite(min) ? min : rangeMin;
+                        var resolvedMax = Number.isFinite(max) ? max : rangeMax;
+                        try {
+                            for (var cellValues_1 = (e_16 = void 0, tslib_1.__values(cellValues)), cellValues_1_1 = cellValues_1.next(); !cellValues_1_1.done; cellValues_1_1 = cellValues_1.next()) {
+                                var cell = cellValues_1_1.value;
+                                var cellId = (0, grid_1.cellIdentifier)(cell.rowIndex, cell.columnIndex);
+                                if (stopCells.has(cellId))
+                                    continue;
+                                var isNegative = cell.value < 0 && negativeColor !== undefined;
+                                var fill = (0, cf_overlays_1.computeDataBarFill)(isNegative ? -cell.value : cell.value, isNegative ? 0 : Math.max(0, resolvedMin), isNegative
+                                    ? Math.abs(resolvedMin)
+                                    : Math.max(resolvedMin, resolvedMax));
+                                var existing = formattingByCell.get(cellId);
+                                formattingByCell.set(cellId, tslib_1.__assign(tslib_1.__assign({}, (existing !== null && existing !== void 0 ? existing : {})), { conditionalDataBar: {
+                                        color: isNegative
+                                            ? negativeColor
+                                            : barColor,
+                                        fillFraction: fill,
+                                        negative: isNegative,
+                                        borderColor: borderColor,
+                                        direction: direction,
+                                    } }));
+                                if (rule.stopIfTrue)
+                                    stopCells.add(cellId);
+                            }
+                        }
+                        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+                        finally {
+                            try {
+                                if (cellValues_1_1 && !cellValues_1_1.done && (_w = cellValues_1.return)) _w.call(cellValues_1);
+                            }
+                            finally { if (e_16) throw e_16.error; }
+                        }
+                    }
+                }
+                catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                finally {
+                    try {
+                        if (ranges_7_1 && !ranges_7_1.done && (_u = ranges_7.return)) _u.call(ranges_7);
+                    }
+                    finally { if (e_14) throw e_14.error; }
+                }
+            }
+            conditionIndex++;
+        };
+        try {
+            for (var rules_1 = tslib_1.__values(rules), rules_1_1 = rules_1.next(); !rules_1_1.done; rules_1_1 = rules_1.next()) {
+                var rule = rules_1_1.value;
+                _loop_1(rule);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (rules_1_1 && !rules_1_1.done && (_a = rules_1.return)) _a.call(rules_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return formattingByCell;
+    }, [
+        sheetId,
+        theme,
+        conditionalFormats,
+        locale,
+        getValidationValue,
+        getPreviousValue,
+        setPreviousValue,
+        isNumberValue,
+        getSheetRowCount,
+        getSheetColumnCount,
+        evaluationWindow,
+        getConditionalFormatResult,
+    ]);
+};
+exports.useConditionalFormatting = useConditionalFormatting;