@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-parser/plugins/xlsx/conditional-formatting.d.ts

@@ -0,0 +1,18 @@
+import type { BooleanCondition, CellFormat, ConditionalFormatRule, DistinctRule, TopBottomRule } from "@rowsncolumns/spreadsheet";
+export declare function parseTopBottomCondition(cfRule: any, format: CellFormat): TopBottomRule | undefined;
+export declare function parseDistinctRule(ruleType: string, format: CellFormat): DistinctRule;
+/**
+ * Parse a boolean rule condition
+ * @param cfRule The conditional formatting rule
+ * @returns BooleanCondition object
+ */
+export declare function parseBooleanCondition(cfRule: any): BooleanCondition | undefined;
+/**
+ * Get conditional formatting rules from a sheet
+ * @param sheetData The sheet data
+ * @param sheetId The sheet ID
+ * @param workbookStyles The workbook styles
+ * @returns Array of ConditionalFormatRule objects
+ */
+export declare function getConditionalFormattingFromSheet(sheetData: any, sheetId: number, workbookStyles: any, indexedColors?: Array<string | undefined>): ConditionalFormatRule[];
+//# sourceMappingURL=conditional-formatting.d.ts.map

package/dist/cjs/excel-parser/plugins/xlsx/conditional-formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-formatting.d.ts","sourceRoot":"","sources":["../../../../../excel-parser/plugins/xlsx/conditional-formatting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,EAGV,qBAAqB,EAGrB,YAAY,EAKZ,aAAa,EACd,MAAM,2BAA2B,CAAC;AAgLnC,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,GAAG,EACX,MAAM,EAAE,UAAU,GACjB,aAAa,GAAG,SAAS,CAuC3B;AAED,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,UAAU,GACjB,YAAY,CAKd;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,GAAG,GACV,gBAAgB,GAAG,SAAS,CAgI9B;AA8KD;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,GAAG,EACd,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,GAAG,EACnB,aAAa,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GACxC,qBAAqB,EAAE,CAsLzB"}

package/dist/cjs/excel-parser/plugins/xlsx/conditional-formatting.js

@@ -0,0 +1,620 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { get, set } from "lodash-es";
+import { getRangeFromAddressRef } from "../../helpers";
+import { extractColor } from "./styles";
+/**
+ * Parse cell format from dxf format definition. Theme color
+ * references (`<color theme="N" tint="T"/>`) are intentionally
+ * preserved as `{ theme, tint }` objects on output — consumers
+ * resolve them via `getStringifiedColor(color, theme)` so users can
+ * switch themes / dark mode and have CF colors re-resolve.
+ * Symmetric with how regular cell `backgroundColor` is stored.
+ *
+ * @param dxf The differential formatting element
+ * @param indexedColors Indexed color palette overrides
+ * @returns CellFormat object
+ */
+function parseDxfFormat(dxf, indexedColors) {
+    var _a, _b;
+    var format = {};
+    // Font formatting. OOXML boolean flag elements default to TRUE when the `val`
+    // attribute is absent, but `val="0"`/`"false"` means explicitly OFF — key presence
+    // alone treated `<strike val="0"/>` (an explicit "not struck" dxf font) as struck.
+    // Mirrors styles.ts' `isTruthyFlagNode` + its `<u val="none"/>` handling.
+    var isTruthyFlagNode = function (node) {
+        var _a, _b, _c;
+        if (node === undefined || node === null)
+            return false;
+        var val = typeof node === "object" ? ((_c = (_b = (_a = node.a$) === null || _a === void 0 ? void 0 : _a.val) !== null && _b !== void 0 ? _b : node["#text"]) !== null && _c !== void 0 ? _c : node) : node;
+        if (val === undefined || val === null || val === true)
+            return true;
+        var str = String(val).toLowerCase();
+        if (str === "" || str === "true" || str === "1")
+            return true;
+        return false;
+    };
+    if (dxf.font) {
+        if ("b" in dxf.font && isTruthyFlagNode(dxf.font.b)) {
+            set(format, "textFormat.bold", true);
+        }
+        if ("i" in dxf.font && isTruthyFlagNode(dxf.font.i)) {
+            set(format, "textFormat.italic", true);
+        }
+        if ("u" in dxf.font) {
+            // Underline is not a boolean — `<u val="none"/>` means no underline; anything
+            // else (including an absent val) is some form of underline.
+            var uNode = dxf.font.u;
+            var uVal = typeof uNode === "object" ? ((_b = (_a = uNode === null || uNode === void 0 ? void 0 : uNode.a$) === null || _a === void 0 ? void 0 : _a.val) !== null && _b !== void 0 ? _b : uNode === null || uNode === void 0 ? void 0 : uNode["#text"]) : uNode;
+            var uStr = uVal === undefined || uVal === null ? "" : String(uVal).toLowerCase();
+            if (uStr !== "none") {
+                set(format, "textFormat.underline", true);
+            }
+        }
+        if ("strike" in dxf.font && isTruthyFlagNode(dxf.font.strike)) {
+            set(format, "textFormat.strikethrough", true);
+        }
+        if (dxf.font.color)
+            set(format, "textFormat.color", extractColor(dxf.font.color, indexedColors));
+    }
+    // Fill formatting
+    if (dxf.fill && dxf.fill.patternFill && dxf.fill.patternFill.bgColor) {
+        format.backgroundColor = extractColor(dxf.fill.patternFill.bgColor, indexedColors);
+    }
+    return format;
+}
+/**
+ * Map Excel condition type to our condition type
+ * @param cfType Excel conditional formatting type
+ * @returns Standardized condition type
+ */
+function mapConditionType(cfType) {
+    var typeMap = {
+        containsText: "TEXT_CONTAINS",
+        notContainsText: "TEXT_NOT_CONTAINS",
+        beginsWith: "TEXT_STARTS_WITH",
+        endsWith: "TEXT_ENDS_WITH",
+        containsBlanks: "BLANK",
+        notContainsBlanks: "NOT_BLANK",
+        containsErrors: "ERROR",
+        notContainsErrors: "NOT_ERROR",
+        expression: "CUSTOM_FORMULA",
+    };
+    return typeMap[cfType] || cfType;
+}
+/**
+ * Map Excel operator to our condition operator
+ * @param operator Excel operator
+ * @returns Standardized operator
+ */
+function mapOperator(operator) {
+    var operatorMap = {
+        lessThan: "NUMBER_LESS",
+        lessThanOrEqual: "NUMBER_LESS_THAN_EQ",
+        equal: "NUMBER_EQ",
+        notEqual: "NUMBER_NOT_EQ",
+        greaterThanOrEqual: "NUMBER_GREATER_THAN_EQ",
+        greaterThan: "NUMBER_GREATER",
+        between: "NUMBER_BETWEEN",
+        notBetween: "NUMBER_NOT_BETWEEN",
+        containsText: "TEXT_CONTAINS",
+    };
+    return operatorMap[operator] || operator;
+}
+function asArray(entry) {
+    if (entry === undefined || entry === null) {
+        return [];
+    }
+    return Array.isArray(entry) ? entry : [entry];
+}
+function extractFormulaText(entry) {
+    var _a;
+    if (entry === undefined || entry === null) {
+        return undefined;
+    }
+    if (typeof entry === "string" || typeof entry === "number") {
+        return String(entry);
+    }
+    if (typeof entry === "object") {
+        var textNode = (typeof entry.t$ === "string" && entry.t$) ||
+            (typeof entry._text === "string" && entry._text) ||
+            (typeof entry["#text"] === "string" && entry["#text"]);
+        var attributeFormula = typeof ((_a = entry === null || entry === void 0 ? void 0 : entry.a$) === null || _a === void 0 ? void 0 : _a["xm:f"]) === "string" ? entry.a$["xm:f"] : undefined;
+        if (textNode && !textNode.trim().startsWith("#REF!")) {
+            return textNode;
+        }
+        if (attributeFormula && attributeFormula.trim()) {
+            return attributeFormula;
+        }
+        if (textNode) {
+            return textNode;
+        }
+    }
+    return undefined;
+}
+function normalizeFormulaExpression(entry) {
+    var text = extractFormulaText(entry);
+    if (text === undefined) {
+        return undefined;
+    }
+    var trimmed = text.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.startsWith("=") ? trimmed : "=".concat(trimmed);
+}
+export function parseTopBottomCondition(cfRule, format) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (!cfRule) {
+        return undefined;
+    }
+    var ruleAttributes = (_a = cfRule.a$) !== null && _a !== void 0 ? _a : {};
+    var top10Node = (_b = cfRule.top10) !== null && _b !== void 0 ? _b : cfRule["x:top10"];
+    var top10Attributes = (_c = top10Node === null || top10Node === void 0 ? void 0 : top10Node.a$) !== null && _c !== void 0 ? _c : {};
+    var attributes = __assign(__assign({}, ruleAttributes), top10Attributes);
+    var rankAttr = (_f = (_e = (_d = attributes.rank) !== null && _d !== void 0 ? _d : attributes.val) !== null && _e !== void 0 ? _e : attributes.value) !== null && _f !== void 0 ? _f : attributes.rankNumber;
+    var rank = rankAttr !== undefined && !Number.isNaN(Number(rankAttr))
+        ? Number(rankAttr)
+        : 10;
+    if (!Number.isFinite(rank) || rank <= 0) {
+        return undefined;
+    }
+    var percentAttr = (_g = attributes.percent) !== null && _g !== void 0 ? _g : attributes.isPercent;
+    var bottomAttr = (_h = attributes.bottom) !== null && _h !== void 0 ? _h : attributes.isBottom;
+    var isPercent = percentAttr === "1" || percentAttr === "true";
+    var isBottom = bottomAttr === "1" || bottomAttr === "true";
+    return {
+        type: isBottom ? "BOTTOM" : "TOP",
+        rank: rank,
+        isPercent: isPercent,
+        format: format,
+    };
+}
+export function parseDistinctRule(ruleType, format) {
+    return {
+        type: ruleType === "duplicateValues" ? "DUPLICATE" : "UNIQUE",
+        format: format,
+    };
+}
+/**
+ * Parse a boolean rule condition
+ * @param cfRule The conditional formatting rule
+ * @returns BooleanCondition object
+ */
+export function parseBooleanCondition(cfRule) {
+    var _a, _b, _c, _d, _e;
+    var rawType = cfRule.a$.type;
+    if (!rawType) {
+        return undefined;
+    }
+    if (rawType === "timePeriod") {
+        var periodMap = {
+            today: "DATE_TODAY",
+            yesterday: "DATE_YESTERDAY",
+            tomorrow: "DATE_TOMORROW",
+            last7Days: "DATE_LAST_7_DAYS",
+            lastWeek: "DATE_LAST_WEEK",
+            thisWeek: "DATE_THIS_WEEK",
+            nextWeek: "DATE_NEXT_WEEK",
+            lastMonth: "DATE_LAST_MONTH",
+            thisMonth: "DATE_THIS_MONTH",
+            nextMonth: "DATE_NEXT_MONTH",
+        };
+        var mapped = periodMap[String((_a = cfRule.a$.timePeriod) !== null && _a !== void 0 ? _a : "")];
+        if (!mapped) {
+            return undefined;
+        }
+        return { type: mapped };
+    }
+    if (rawType === "aboveAverage") {
+        var aboveAverage = String((_b = cfRule.a$.aboveAverage) !== null && _b !== void 0 ? _b : "1") !== "0";
+        return {
+            type: aboveAverage ? "NUMBER_ABOVE_AVERAGE" : "NUMBER_BELOW_AVERAGE",
+        };
+    }
+    var type = mapConditionType(rawType);
+    if (!type) {
+        return undefined;
+    }
+    var condition = {
+        type: type,
+    };
+    // Parse operators and values
+    var operator = cfRule.a$.operator;
+    if (cfRule.a$.operator) {
+        condition.type = mapOperator(cfRule.a$.operator);
+    }
+    // Parse formula values
+    var values = [];
+    // Handle both with and without namespace prefix
+    var formulaEntries = asArray((_c = cfRule.formula) !== null && _c !== void 0 ? _c : cfRule["x:formula"]);
+    var formula1Entries = asArray((_d = cfRule.formula1) !== null && _d !== void 0 ? _d : cfRule["x:formula1"]);
+    var formula2Entries = asArray((_e = cfRule.formula2) !== null && _e !== void 0 ? _e : cfRule["x:formula2"]);
+    var effectiveFormulaEntries = formulaEntries.length > 0
+        ? formulaEntries
+        : __spreadArray(__spreadArray([], __read(formula1Entries), false), __read(formula2Entries), false);
+    if (condition.type === "CUSTOM_FORMULA") {
+        effectiveFormulaEntries.forEach(function (entry) {
+            var normalized = normalizeFormulaExpression(entry);
+            if (normalized !== undefined) {
+                values.push({ userEnteredValue: normalized });
+            }
+        });
+    }
+    else if (["containsText", "notContainsText", "beginsWith", "endsWith"].includes(rawType)) {
+        // Prefer text attribute for text based rules, ignore implementation formula
+        if (cfRule.a$.text) {
+            values.push({ userEnteredValue: cfRule.a$.text });
+        }
+    }
+    else if ([
+        "containsBlanks",
+        "notContainsBlanks",
+        "containsErrors",
+        "notContainsErrors",
+    ].includes(rawType)) {
+        // Ignore values for these rules
+    }
+    else {
+        // Default behavior (e.g. cellIs): use formula values as literals
+        var hasQuotedTextLiteral_1 = false;
+        effectiveFormulaEntries.forEach(function (entry) {
+            var text = extractFormulaText(entry);
+            if (text !== undefined) {
+                var trimmed = text.trim();
+                var isQuoted = (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+                    (trimmed.startsWith("'") && trimmed.endsWith("'"));
+                // Check if numeric (simple check)
+                var isNumeric = !isNaN(Number(trimmed));
+                if (isQuoted) {
+                    // Quoted string literal -> Scalar string
+                    hasQuotedTextLiteral_1 = true;
+                    values.push({ userEnteredValue: trimmed.slice(1, -1) });
+                }
+                else if (isNumeric) {
+                    // Numeric literal -> Scalar number
+                    values.push({ userEnteredValue: trimmed });
+                }
+                else {
+                    // Reference or Formula -> Formula value (prepend =)
+                    var val = trimmed.startsWith("=") ? trimmed : "=".concat(trimmed);
+                    values.push({ userEnteredValue: val });
+                }
+            }
+        });
+        if (values.length === 0 && cfRule.a$.text) {
+            hasQuotedTextLiteral_1 = true;
+            values.push({ userEnteredValue: cfRule.a$.text });
+        }
+        if (rawType === "cellIs" &&
+            hasQuotedTextLiteral_1 &&
+            (operator === "equal" || operator === "notEqual")) {
+            condition.type = operator === "equal" ? "TEXT_EQ" : "TEXT_NOT_EQ";
+        }
+    }
+    if (values.length > 0) {
+        condition.values = values;
+    }
+    return condition;
+}
+/**
+ * Parse color scale rule
+ * @param cfRule The conditional formatting rule
+ * @param dxfs The differential formatting styles
+ * @param workbookStyles The workbook styles
+ * @returns GradientRule object
+ */
+function parseColorScaleRule(cfRule, indexedColors) {
+    var _a, _b, _c, _d, _e;
+    var gradientRule = {};
+    // Handle both with and without namespace prefix
+    var colorScale = (_a = cfRule.colorScale) !== null && _a !== void 0 ? _a : cfRule["x:colorScale"];
+    if (!colorScale)
+        return gradientRule;
+    var cfColors = (_c = (_b = colorScale.color) !== null && _b !== void 0 ? _b : colorScale["x:color"]) !== null && _c !== void 0 ? _c : [];
+    var cfValues = (_e = (_d = colorScale.cfvo) !== null && _d !== void 0 ? _d : colorScale["x:cfvo"]) !== null && _e !== void 0 ? _e : [];
+    var colorsArray = Array.isArray(cfColors) ? cfColors : [cfColors];
+    var valuesArray = Array.isArray(cfValues) ? cfValues : [cfValues];
+    // Parse min point
+    if (valuesArray.length > 0 && colorsArray.length > 0) {
+        var minValue = valuesArray[0];
+        var minValueType = minValue.a$.type.toUpperCase();
+        gradientRule.minpoint = {
+            color: extractColor(colorsArray[0], indexedColors),
+            type: minValueType,
+        };
+        if (minValue.a$.val) {
+            set(gradientRule, "minpoint.value", minValue.a$.val);
+        }
+    }
+    // Parse mid point (if exists)
+    if (valuesArray.length > 2 && colorsArray.length > 2) {
+        var midValue = valuesArray[1];
+        var midValueType = midValue.a$.type.toUpperCase();
+        gradientRule.midpoint = {
+            color: extractColor(colorsArray[1], indexedColors),
+            type: midValueType,
+        };
+        if (midValue.a$.val) {
+            set(gradientRule, "midpoint.value", midValue.a$.val);
+        }
+    }
+    // Parse max point
+    if (valuesArray.length > 1 && colorsArray.length > 1) {
+        var maxIndex = valuesArray.length - 1;
+        var maxValue = valuesArray[maxIndex];
+        var maxValueType = maxValue.a$.type.toUpperCase();
+        gradientRule.maxpoint = {
+            color: extractColor(colorsArray[maxIndex], indexedColors),
+            type: maxValueType,
+        };
+        if (maxValue.a$.val) {
+            set(gradientRule, "maxpoint.value", maxValue.a$.val);
+        }
+    }
+    return gradientRule;
+}
+// Map OOXML cfvo type → engine threshold type. OOXML uses lowercase strings;
+// our engine uses uppercase enum values.
+function mapCfvoType(rawType) {
+    var t = (rawType !== null && rawType !== void 0 ? rawType : "").toLowerCase();
+    if (t === "min")
+        return "MIN";
+    if (t === "max")
+        return "MAX";
+    if (t === "num")
+        return "NUMBER";
+    if (t === "percent")
+        return "PERCENT";
+    if (t === "percentile")
+        return "PERCENTILE";
+    if (t === "formula")
+        return "FORMULA";
+    return "NUMBER";
+}
+function parseCfvoArray(cfvos) {
+    if (!cfvos)
+        return [];
+    var array = Array.isArray(cfvos) ? cfvos : [cfvos];
+    return array.map(function (v) {
+        var _a, _b;
+        return (__assign({ type: mapCfvoType((_a = v === null || v === void 0 ? void 0 : v.a$) === null || _a === void 0 ? void 0 : _a.type) }, (((_b = v === null || v === void 0 ? void 0 : v.a$) === null || _b === void 0 ? void 0 : _b.val) !== undefined ? { value: v.a$.val } : {})));
+    });
+}
+var KNOWN_ICON_SET_FAMILIES = new Set([
+    "3Arrows",
+    "3ArrowsGray",
+    "3Flags",
+    "3TrafficLights1",
+    "3TrafficLights2",
+    "3Signs",
+    "3Symbols",
+    "3Symbols2",
+    "4Arrows",
+    "4ArrowsGray",
+    "4RedToBlack",
+    "4Rating",
+    "4TrafficLights",
+    "5Arrows",
+    "5ArrowsGray",
+    "5Rating",
+    "5Quarters",
+]);
+function parseIconSetRule(cfRule) {
+    var _a, _b, _c, _d, _e, _f;
+    var iconSet = (_a = cfRule.iconSet) !== null && _a !== void 0 ? _a : cfRule["x:iconSet"];
+    if (!iconSet)
+        return null;
+    var familyRaw = (_c = (_b = iconSet === null || iconSet === void 0 ? void 0 : iconSet.a$) === null || _b === void 0 ? void 0 : _b.iconSet) !== null && _c !== void 0 ? _c : "3TrafficLights1";
+    var family = (KNOWN_ICON_SET_FAMILIES.has(familyRaw) ? familyRaw : "3TrafficLights1");
+    var cfvos = (_d = iconSet.cfvo) !== null && _d !== void 0 ? _d : iconSet["x:cfvo"];
+    var thresholds = parseCfvoArray(cfvos);
+    // OOXML always includes a leading "MIN/0%" cfvo for icon sets; drop it
+    // because the engine treats thresholds[i] as the lower bound for bucket i+1.
+    var effective = thresholds.length > 1 ? thresholds.slice(1) : thresholds;
+    var rule = {
+        iconSet: family,
+        thresholds: effective,
+    };
+    if (((_e = iconSet.a$) === null || _e === void 0 ? void 0 : _e.reverse) === "1")
+        rule.reverse = true;
+    if (((_f = iconSet.a$) === null || _f === void 0 ? void 0 : _f.showValue) === "0")
+        rule.showValue = false;
+    return rule;
+}
+function parseDataBarRule(cfRule, indexedColors) {
+    var _a, _b, _c, _d;
+    var dataBar = (_a = cfRule.dataBar) !== null && _a !== void 0 ? _a : cfRule["x:dataBar"];
+    if (!dataBar)
+        return null;
+    var cfvos = parseCfvoArray((_b = dataBar.cfvo) !== null && _b !== void 0 ? _b : dataBar["x:cfvo"]);
+    if (cfvos.length < 2)
+        return null;
+    var colorNode = (_c = dataBar.color) !== null && _c !== void 0 ? _c : dataBar["x:color"];
+    var color = extractColor(Array.isArray(colorNode) ? colorNode[0] : colorNode, indexedColors);
+    if (!color)
+        return null;
+    var rule = {
+        minpoint: cfvos[0],
+        maxpoint: cfvos[cfvos.length - 1],
+        color: color,
+    };
+    if (((_d = dataBar.a$) === null || _d === void 0 ? void 0 : _d.showValue) === "0")
+        rule.showValue = false;
+    return rule;
+}
+/**
+ * Get conditional formatting rules from a sheet
+ * @param sheetData The sheet data
+ * @param sheetId The sheet ID
+ * @param workbookStyles The workbook styles
+ * @returns Array of ConditionalFormatRule objects
+ */
+export function getConditionalFormattingFromSheet(sheetData, sheetId, workbookStyles, indexedColors) {
+    var conditionalFormatRules = [];
+    // Get conditional formatting entries
+    // Handle both with and without namespace prefix
+    var conditionalFormattingEntries = get(sheetData, "worksheet.conditionalFormatting") ||
+        get(sheetData, "x:worksheet.x:conditionalFormatting");
+    if (!conditionalFormattingEntries)
+        return [];
+    // Normalize to array
+    var cfEntries = Array.isArray(conditionalFormattingEntries)
+        ? conditionalFormattingEntries
+        : [conditionalFormattingEntries];
+    // Get dxfs (differential formatting) if available
+    var dxfs = get(workbookStyles, "dxfs.dxf") || [];
+    var dxfsArray = Array.isArray(dxfs) ? dxfs : [dxfs];
+    // Process each conditional formatting entry
+    cfEntries.forEach(function (cfEntry, index) {
+        var _a, _b;
+        // Get the range(s) this formatting applies to
+        var sqref = cfEntry.a$ && cfEntry.a$.sqref;
+        if (!sqref)
+            return;
+        // Split multiple ranges (Excel uses space as delimiter)
+        var rangeAddresses = sqref.split(" ");
+        var ranges = [];
+        // Convert each Excel range to our SheetRange format
+        rangeAddresses.forEach(function (address) {
+            var range = getRangeFromAddressRef(address);
+            if (range) {
+                ranges.push(__assign(__assign({}, range), { sheetId: sheetId }));
+            }
+        });
+        if (ranges.length === 0)
+            return;
+        // Get the formatting rules
+        // Handle both with and without namespace prefix
+        var cfRules = (_b = (_a = cfEntry.cfRule) !== null && _a !== void 0 ? _a : cfEntry["x:cfRule"]) !== null && _b !== void 0 ? _b : [];
+        var cfRulesArray = Array.isArray(cfRules) ? cfRules : [cfRules];
+        // Process each rule
+        cfRulesArray.forEach(function (cfRule, ruleIndex) {
+            var e_1, _a;
+            var _b, _c, _d, _e, _f, _g;
+            var rule = {
+                id: "".concat(sheetId, "_").concat(index, "_").concat(ruleIndex),
+                ranges: ranges,
+            };
+            if (((_b = cfRule.a$) === null || _b === void 0 ? void 0 : _b.priority) !== undefined) {
+                var parsedPriority = Number.parseInt(cfRule.a$.priority, 10);
+                if (!Number.isNaN(parsedPriority)) {
+                    rule.priority = parsedPriority;
+                }
+            }
+            if (((_c = cfRule.a$) === null || _c === void 0 ? void 0 : _c.stopIfTrue) === "1") {
+                rule.stopIfTrue = true;
+            }
+            // Check if rule is disabled
+            if (cfRule.a$ && cfRule.a$.disabled === "1") {
+                rule.enabled = false;
+            }
+            // Process different rule types
+            var ruleType = cfRule.a$.type;
+            // Capture the verbatim source representation so the exporter can replay
+            // it exactly — preserves cfRule `type` (`containsText`/`beginsWith`/
+            // `timePeriod`/etc.), the original operator, the user's formula text,
+            // and rule attrs (`text`, `rank`, `percent`, `aboveAverage`, etc.) that
+            // would otherwise be lost when the rule round-trips through the
+            // synthesizing exporter. For `colorScale`/`dataBar`/`iconSet` rules,
+            // the relevant data lives in nested child elements with stop points,
+            // colors, and value thresholds — capture those subtrees opaquely so
+            // the exporter can re-emit them via XMLBuilder verbatim.
+            if (ruleType) {
+                var formulaNodes = (_d = cfRule.formula) !== null && _d !== void 0 ? _d : cfRule["x:formula"];
+                var formulaArray = formulaNodes
+                    ? Array.isArray(formulaNodes)
+                        ? formulaNodes
+                        : [formulaNodes]
+                    : [];
+                var formulas = [];
+                try {
+                    for (var formulaArray_1 = __values(formulaArray), formulaArray_1_1 = formulaArray_1.next(); !formulaArray_1_1.done; formulaArray_1_1 = formulaArray_1.next()) {
+                        var fNode = formulaArray_1_1.value;
+                        var text = extractFormulaText(fNode);
+                        if (text !== undefined && String(text).length > 0) {
+                            var trimmed = String(text).trim();
+                            formulas.push(trimmed.startsWith("=") ? trimmed.slice(1) : trimmed);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (formulaArray_1_1 && !formulaArray_1_1.done && (_a = formulaArray_1.return)) _a.call(formulaArray_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                var numericAttr = function (key) {
+                    var _a;
+                    if (((_a = cfRule.a$) === null || _a === void 0 ? void 0 : _a[key]) === undefined)
+                        return undefined;
+                    var n = Number(cfRule.a$[key]);
+                    return Number.isFinite(n) ? n : undefined;
+                };
+                var colorScaleNode = (_e = cfRule.colorScale) !== null && _e !== void 0 ? _e : cfRule["x:colorScale"];
+                var dataBarNode = (_f = cfRule.dataBar) !== null && _f !== void 0 ? _f : cfRule["x:dataBar"];
+                var iconSetNode = (_g = cfRule.iconSet) !== null && _g !== void 0 ? _g : cfRule["x:iconSet"];
+                rule.xlsxSource = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ type: ruleType }, (cfRule.a$.operator
+                    ? { operator: cfRule.a$.operator }
+                    : {})), (cfRule.a$.text ? { text: cfRule.a$.text } : {})), (cfRule.a$.timePeriod
+                    ? { timePeriod: cfRule.a$.timePeriod }
+                    : {})), (numericAttr("rank") !== undefined
+                    ? { rank: numericAttr("rank") }
+                    : {})), (cfRule.a$.percent === "1" ? { percent: true } : {})), (cfRule.a$.bottom === "1" ? { bottom: true } : {})), (cfRule.a$.aboveAverage === "0"
+                    ? { aboveAverage: false }
+                    : cfRule.a$.aboveAverage === "1"
+                        ? { aboveAverage: true }
+                        : {})), (cfRule.a$.equalAverage === "1"
+                    ? { equalAverage: true }
+                    : {})), (numericAttr("stdDev") !== undefined
+                    ? { stdDev: numericAttr("stdDev") }
+                    : {})), (formulas.length ? { formulas: formulas } : {})), (colorScaleNode ? { colorScale: colorScaleNode } : {})), (dataBarNode ? { dataBar: dataBarNode } : {})), (iconSetNode ? { iconSet: iconSetNode } : {}));
+            }
+            // Handle color scale (gradient) rules
+            if (ruleType === "colorScale") {
+                rule.gradientRule = parseColorScaleRule(cfRule, indexedColors);
+            }
+            else if (ruleType === "iconSet") {
+                var parsed = parseIconSetRule(cfRule);
+                if (parsed)
+                    rule.iconSetRule = parsed;
+            }
+            else if (ruleType === "dataBar") {
+                var parsed = parseDataBarRule(cfRule, indexedColors);
+                if (parsed)
+                    rule.dataBarRule = parsed;
+            }
+            else {
+                // Get formatting from dxf if available
+                var format = {};
+                if (cfRule.a$.dxfId !== undefined) {
+                    var dxfId = parseInt(cfRule.a$.dxfId);
+                    if (dxfId >= 0 && dxfId < dxfsArray.length) {
+                        format = parseDxfFormat(dxfsArray[dxfId], indexedColors);
+                    }
+                }
+                if (ruleType === "top10") {
+                    var topBottomRule = parseTopBottomCondition(cfRule, format);
+                    if (topBottomRule) {
+                        rule.topBottomRule = topBottomRule;
+                    }
+                }
+                else if (ruleType === "duplicateValues" ||
+                    ruleType === "uniqueValues") {
+                    rule.distinctRule = parseDistinctRule(ruleType, format);
+                }
+                else {
+                    var condition = parseBooleanCondition(cfRule);
+                    if (condition) {
+                        rule.booleanRule = {
+                            condition: condition,
+                            format: format,
+                        };
+                    }
+                }
+            }
+            conditionalFormatRules.push(rule);
+        });
+    });
+    return conditionalFormatRules;
+}

package/dist/cjs/excel-parser/plugins/xlsx/data-validations.d.ts

@@ -0,0 +1,4 @@
+import type { DataValidationRuleRecord } from "@rowsncolumns/spreadsheet";
+import type { IWorkbookPlugin } from "../../interface";
+export declare const getDataValidationsForSheet: (workbook: IWorkbookPlugin, sheetId: number, sheet_data: any, sheetName?: string) => DataValidationRuleRecord[];
+//# sourceMappingURL=data-validations.d.ts.map

package/dist/cjs/excel-parser/plugins/xlsx/data-validations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-validations.d.ts","sourceRoot":"","sources":["../../../../../excel-parser/plugins/xlsx/data-validations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,wBAAwB,EAEzB,MAAM,2BAA2B,CAAC;AASnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAwSvD,eAAO,MAAM,0BAA0B,GACrC,UAAU,eAAe,EACzB,SAAS,MAAM,EACf,YAAY,GAAG,EACf,YAAY,MAAM,+BAyRnB,CAAC"}