@rowsncolumns/toolkit 24.4.1

package/dist/esm/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/esm/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/esm/excel-parser/plugins/xlsx/conditional-formatting.js

@@ -0,0 +1,621 @@
+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) {
+    const 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.
+    const isTruthyFlagNode = (node) => {
+        if (node === undefined || node === null)
+            return false;
+        const val = typeof node === "object" ? (node.a$?.val ?? node["#text"] ?? node) : node;
+        if (val === undefined || val === null || val === true)
+            return true;
+        const 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.
+            const uNode = dxf.font.u;
+            const uVal = typeof uNode === "object" ? (uNode?.a$?.val ?? uNode?.["#text"]) : uNode;
+            const 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) {
+    const 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) {
+    const 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) {
+    if (entry === undefined || entry === null) {
+        return undefined;
+    }
+    if (typeof entry === "string" || typeof entry === "number") {
+        return String(entry);
+    }
+    if (typeof entry === "object") {
+        const textNode = (typeof entry.t$ === "string" && entry.t$) ||
+            (typeof entry._text === "string" && entry._text) ||
+            (typeof entry["#text"] === "string" && entry["#text"]);
+        const attributeFormula = typeof entry?.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) {
+    const text = extractFormulaText(entry);
+    if (text === undefined) {
+        return undefined;
+    }
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.startsWith("=") ? trimmed : `=${trimmed}`;
+}
+export function parseTopBottomCondition(cfRule, format) {
+    if (!cfRule) {
+        return undefined;
+    }
+    const ruleAttributes = cfRule.a$ ?? {};
+    const top10Node = cfRule.top10 ?? cfRule["x:top10"];
+    const top10Attributes = top10Node?.a$ ?? {};
+    const attributes = {
+        ...ruleAttributes,
+        ...top10Attributes,
+    };
+    const rankAttr = attributes.rank ??
+        attributes.val ??
+        attributes.value ??
+        attributes.rankNumber;
+    const rank = rankAttr !== undefined && !Number.isNaN(Number(rankAttr))
+        ? Number(rankAttr)
+        : 10;
+    if (!Number.isFinite(rank) || rank <= 0) {
+        return undefined;
+    }
+    const percentAttr = attributes.percent ?? attributes.isPercent;
+    const bottomAttr = attributes.bottom ?? attributes.isBottom;
+    const isPercent = percentAttr === "1" || percentAttr === "true";
+    const isBottom = bottomAttr === "1" || bottomAttr === "true";
+    return {
+        type: isBottom ? "BOTTOM" : "TOP",
+        rank,
+        isPercent,
+        format,
+    };
+}
+export function parseDistinctRule(ruleType, format) {
+    return {
+        type: ruleType === "duplicateValues" ? "DUPLICATE" : "UNIQUE",
+        format,
+    };
+}
+/**
+ * Parse a boolean rule condition
+ * @param cfRule The conditional formatting rule
+ * @returns BooleanCondition object
+ */
+export function parseBooleanCondition(cfRule) {
+    const rawType = cfRule.a$.type;
+    if (!rawType) {
+        return undefined;
+    }
+    if (rawType === "timePeriod") {
+        const 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",
+        };
+        const mapped = periodMap[String(cfRule.a$.timePeriod ?? "")];
+        if (!mapped) {
+            return undefined;
+        }
+        return { type: mapped };
+    }
+    if (rawType === "aboveAverage") {
+        const aboveAverage = String(cfRule.a$.aboveAverage ?? "1") !== "0";
+        return {
+            type: aboveAverage ? "NUMBER_ABOVE_AVERAGE" : "NUMBER_BELOW_AVERAGE",
+        };
+    }
+    const type = mapConditionType(rawType);
+    if (!type) {
+        return undefined;
+    }
+    const condition = {
+        type,
+    };
+    // Parse operators and values
+    const operator = cfRule.a$.operator;
+    if (cfRule.a$.operator) {
+        condition.type = mapOperator(cfRule.a$.operator);
+    }
+    // Parse formula values
+    const values = [];
+    // Handle both with and without namespace prefix
+    const formulaEntries = asArray(cfRule.formula ?? cfRule["x:formula"]);
+    const formula1Entries = asArray(cfRule.formula1 ?? cfRule["x:formula1"]);
+    const formula2Entries = asArray(cfRule.formula2 ?? cfRule["x:formula2"]);
+    const effectiveFormulaEntries = formulaEntries.length > 0
+        ? formulaEntries
+        : [...formula1Entries, ...formula2Entries];
+    if (condition.type === "CUSTOM_FORMULA") {
+        effectiveFormulaEntries.forEach((entry) => {
+            const 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
+        let hasQuotedTextLiteral = false;
+        effectiveFormulaEntries.forEach((entry) => {
+            const text = extractFormulaText(entry);
+            if (text !== undefined) {
+                const trimmed = text.trim();
+                const isQuoted = (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+                    (trimmed.startsWith("'") && trimmed.endsWith("'"));
+                // Check if numeric (simple check)
+                const isNumeric = !isNaN(Number(trimmed));
+                if (isQuoted) {
+                    // Quoted string literal -> Scalar string
+                    hasQuotedTextLiteral = 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 =)
+                    const val = trimmed.startsWith("=") ? trimmed : `=${trimmed}`;
+                    values.push({ userEnteredValue: val });
+                }
+            }
+        });
+        if (values.length === 0 && cfRule.a$.text) {
+            hasQuotedTextLiteral = true;
+            values.push({ userEnteredValue: cfRule.a$.text });
+        }
+        if (rawType === "cellIs" &&
+            hasQuotedTextLiteral &&
+            (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) {
+    const gradientRule = {};
+    // Handle both with and without namespace prefix
+    const colorScale = cfRule.colorScale ?? cfRule["x:colorScale"];
+    if (!colorScale)
+        return gradientRule;
+    const cfColors = colorScale.color ?? colorScale["x:color"] ?? [];
+    const cfValues = colorScale.cfvo ?? colorScale["x:cfvo"] ?? [];
+    const colorsArray = Array.isArray(cfColors) ? cfColors : [cfColors];
+    const valuesArray = Array.isArray(cfValues) ? cfValues : [cfValues];
+    // Parse min point
+    if (valuesArray.length > 0 && colorsArray.length > 0) {
+        const minValue = valuesArray[0];
+        const 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) {
+        const midValue = valuesArray[1];
+        const 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) {
+        const maxIndex = valuesArray.length - 1;
+        const maxValue = valuesArray[maxIndex];
+        const 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) {
+    const t = (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 [];
+    const array = Array.isArray(cfvos) ? cfvos : [cfvos];
+    return array.map((v) => ({
+        type: mapCfvoType(v?.a$?.type),
+        ...(v?.a$?.val !== undefined ? { value: v.a$.val } : {}),
+    }));
+}
+const 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) {
+    const iconSet = cfRule.iconSet ?? cfRule["x:iconSet"];
+    if (!iconSet)
+        return null;
+    const familyRaw = iconSet?.a$?.iconSet ?? "3TrafficLights1";
+    const family = (KNOWN_ICON_SET_FAMILIES.has(familyRaw) ? familyRaw : "3TrafficLights1");
+    const cfvos = iconSet.cfvo ?? iconSet["x:cfvo"];
+    const 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.
+    const effective = thresholds.length > 1 ? thresholds.slice(1) : thresholds;
+    const rule = {
+        iconSet: family,
+        thresholds: effective,
+    };
+    if (iconSet.a$?.reverse === "1")
+        rule.reverse = true;
+    if (iconSet.a$?.showValue === "0")
+        rule.showValue = false;
+    return rule;
+}
+function parseDataBarRule(cfRule, indexedColors) {
+    const dataBar = cfRule.dataBar ?? cfRule["x:dataBar"];
+    if (!dataBar)
+        return null;
+    const cfvos = parseCfvoArray(dataBar.cfvo ?? dataBar["x:cfvo"]);
+    if (cfvos.length < 2)
+        return null;
+    const colorNode = dataBar.color ?? dataBar["x:color"];
+    const color = extractColor(Array.isArray(colorNode) ? colorNode[0] : colorNode, indexedColors);
+    if (!color)
+        return null;
+    const rule = {
+        minpoint: cfvos[0],
+        maxpoint: cfvos[cfvos.length - 1],
+        color,
+    };
+    if (dataBar.a$?.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) {
+    const conditionalFormatRules = [];
+    // Get conditional formatting entries
+    // Handle both with and without namespace prefix
+    const conditionalFormattingEntries = get(sheetData, "worksheet.conditionalFormatting") ||
+        get(sheetData, "x:worksheet.x:conditionalFormatting");
+    if (!conditionalFormattingEntries)
+        return [];
+    // Normalize to array
+    const cfEntries = Array.isArray(conditionalFormattingEntries)
+        ? conditionalFormattingEntries
+        : [conditionalFormattingEntries];
+    // Get dxfs (differential formatting) if available
+    const dxfs = get(workbookStyles, "dxfs.dxf") || [];
+    const dxfsArray = Array.isArray(dxfs) ? dxfs : [dxfs];
+    // Process each conditional formatting entry
+    cfEntries.forEach((cfEntry, index) => {
+        // Get the range(s) this formatting applies to
+        const sqref = cfEntry.a$ && cfEntry.a$.sqref;
+        if (!sqref)
+            return;
+        // Split multiple ranges (Excel uses space as delimiter)
+        const rangeAddresses = sqref.split(" ");
+        const ranges = [];
+        // Convert each Excel range to our SheetRange format
+        rangeAddresses.forEach((address) => {
+            const range = getRangeFromAddressRef(address);
+            if (range) {
+                ranges.push({
+                    ...range,
+                    sheetId,
+                });
+            }
+        });
+        if (ranges.length === 0)
+            return;
+        // Get the formatting rules
+        // Handle both with and without namespace prefix
+        const cfRules = cfEntry.cfRule ?? cfEntry["x:cfRule"] ?? [];
+        const cfRulesArray = Array.isArray(cfRules) ? cfRules : [cfRules];
+        // Process each rule
+        cfRulesArray.forEach((cfRule, ruleIndex) => {
+            const rule = {
+                id: `${sheetId}_${index}_${ruleIndex}`,
+                ranges,
+            };
+            if (cfRule.a$?.priority !== undefined) {
+                const parsedPriority = Number.parseInt(cfRule.a$.priority, 10);
+                if (!Number.isNaN(parsedPriority)) {
+                    rule.priority = parsedPriority;
+                }
+            }
+            if (cfRule.a$?.stopIfTrue === "1") {
+                rule.stopIfTrue = true;
+            }
+            // Check if rule is disabled
+            if (cfRule.a$ && cfRule.a$.disabled === "1") {
+                rule.enabled = false;
+            }
+            // Process different rule types
+            const 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) {
+                const formulaNodes = cfRule.formula ?? cfRule["x:formula"];
+                const formulaArray = formulaNodes
+                    ? Array.isArray(formulaNodes)
+                        ? formulaNodes
+                        : [formulaNodes]
+                    : [];
+                const formulas = [];
+                for (const fNode of formulaArray) {
+                    const text = extractFormulaText(fNode);
+                    if (text !== undefined && String(text).length > 0) {
+                        const trimmed = String(text).trim();
+                        formulas.push(trimmed.startsWith("=") ? trimmed.slice(1) : trimmed);
+                    }
+                }
+                const numericAttr = (key) => {
+                    if (cfRule.a$?.[key] === undefined)
+                        return undefined;
+                    const n = Number(cfRule.a$[key]);
+                    return Number.isFinite(n) ? n : undefined;
+                };
+                const colorScaleNode = cfRule.colorScale ?? cfRule["x:colorScale"];
+                const dataBarNode = cfRule.dataBar ?? cfRule["x:dataBar"];
+                const iconSetNode = cfRule.iconSet ?? cfRule["x:iconSet"];
+                rule.xlsxSource = {
+                    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 } : {}),
+                    ...(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") {
+                const parsed = parseIconSetRule(cfRule);
+                if (parsed)
+                    rule.iconSetRule = parsed;
+            }
+            else if (ruleType === "dataBar") {
+                const parsed = parseDataBarRule(cfRule, indexedColors);
+                if (parsed)
+                    rule.dataBarRule = parsed;
+            }
+            else {
+                // Get formatting from dxf if available
+                let format = {};
+                if (cfRule.a$.dxfId !== undefined) {
+                    const dxfId = parseInt(cfRule.a$.dxfId);
+                    if (dxfId >= 0 && dxfId < dxfsArray.length) {
+                        format = parseDxfFormat(dxfsArray[dxfId], indexedColors);
+                    }
+                }
+                if (ruleType === "top10") {
+                    const topBottomRule = parseTopBottomCondition(cfRule, format);
+                    if (topBottomRule) {
+                        rule.topBottomRule = topBottomRule;
+                    }
+                }
+                else if (ruleType === "duplicateValues" ||
+                    ruleType === "uniqueValues") {
+                    rule.distinctRule = parseDistinctRule(ruleType, format);
+                }
+                else {
+                    const condition = parseBooleanCondition(cfRule);
+                    if (condition) {
+                        rule.booleanRule = {
+                            condition,
+                            format,
+                        };
+                    }
+                }
+            }
+            conditionalFormatRules.push(rule);
+        });
+    });
+    return conditionalFormatRules;
+}

package/dist/esm/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/esm/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"}