@rowsncolumns/toolkit 24.4.1

package/dist/esm/excel-parser/plugins/ods/conditional-formatting.js

@@ -0,0 +1,405 @@
+import { get } from "lodash-es";
+import { convertOdsFormulaToExcel } from "./formula";
+export function extractConditionalFormats(ctx) {
+    const { sheetContexts, sheetNameMap, odsStyles, getAttributes, parseRangeList, normalizeExpression, normalizeConditionExpression, toArray, } = ctx;
+    if (!sheetContexts.length)
+        return [];
+    const rules = [];
+    let ruleCounter = 1;
+    for (const context of sheetContexts) {
+        const conditionNodes = [
+            ...toArray(get(context.node, "table:table-conditional-format")),
+            ...toArray(get(context.node, "table:table-conditional-formats.table:table-conditional-format")),
+            ...toArray(get(context.node, "table-conditional-format")),
+            ...toArray(get(context.node, "calcext:conditional-formats.calcext:conditional-format")),
+            ...toArray(get(context.node, "calcext:conditional-format")),
+        ];
+        for (const node of conditionNodes) {
+            const attrs = getAttributes(node);
+            if (!attrs)
+                continue;
+            const iconSetNode = get(node, "calcext:icon-set") || get(node, "icon-set");
+            const dataBarNode = get(node, "calcext:data-bar") || get(node, "data-bar");
+            const nestedConditions = toArray(get(node, "table:condition") ||
+                get(node, "condition") ||
+                get(node, "calcext:condition"));
+            const baseAddressAttr = attrs["@_calcext:base-cell-address"] ||
+                extractCalcextBaseAddress(nestedConditions, getAttributes);
+            let ranges = parseRangeList(attrs["@_calcext:target-range-address"] ||
+                attrs["@_table:target-range-address"] ||
+                attrs["@_target-range-address"], sheetNameMap, context);
+            if (!ranges.length && baseAddressAttr) {
+                ranges = parseRangeList(baseAddressAttr, sheetNameMap, context);
+            }
+            if (!ranges.length)
+                continue;
+            const nestedStyleName = extractStyleNameFromConditions(nestedConditions, getAttributes);
+            const styleName = nestedStyleName ||
+                attrs["@_calcext:apply-style-name"] ||
+                attrs["@_table:apply-style-name"] ||
+                attrs["@_table:style-name"] ||
+                attrs["@_style:apply-style-name"];
+            const stopIfTrueAttr = attrs["@_calcext:stop-if-true"] ||
+                attrs["@_table:stop-if-true"] ||
+                attrs["@_stop-if-true"];
+            const format = styleName ? odsStyles.getStyle(styleName) : undefined;
+            const calcextConditionValue = attrs["@_calcext:value"] ||
+                extractCalcextConditionValue(nestedConditions, getAttributes);
+            const rawCondition = attrs["@_table:condition"] ||
+                attrs["@_condition"] ||
+                extractConditionExpression(nestedConditions, getAttributes);
+            const parsedCalcextCondition = parseCalcextCondition(calcextConditionValue);
+            const formula = !parsedCalcextCondition
+                ? calcextConditionValue
+                    ? normalizeExpression(calcextConditionValue)
+                    : normalizeConditionExpression(rawCondition)
+                : undefined;
+            // Skip cells that have neither a boolean condition nor a rich CF
+            // extension (icon set / data bar). We still emit a rule when one of
+            // the calcext extensions is present.
+            if (!format &&
+                !formula &&
+                !parsedCalcextCondition &&
+                !iconSetNode &&
+                !dataBarNode) {
+                continue;
+            }
+            const priority = ruleCounter++;
+            const rule = {
+                id: `ods-cf-${context.sheetId}-${priority}`,
+                ranges,
+                priority,
+            };
+            if (stopIfTrueAttr === "true" || stopIfTrueAttr === "1") {
+                rule.stopIfTrue = true;
+            }
+            if (iconSetNode) {
+                const parsed = parseCalcextIconSet(iconSetNode, getAttributes, toArray);
+                if (parsed) {
+                    rule.iconSetRule = parsed;
+                    rules.push(rule);
+                    continue;
+                }
+            }
+            if (dataBarNode) {
+                const parsed = parseCalcextDataBar(dataBarNode, getAttributes, toArray);
+                if (parsed) {
+                    rule.dataBarRule = parsed;
+                    rules.push(rule);
+                    continue;
+                }
+            }
+            if (format || formula || parsedCalcextCondition) {
+                const condition = parsedCalcextCondition ||
+                    (formula
+                        ? {
+                            type: "CUSTOM_FORMULA",
+                            values: [{ userEnteredValue: formula }],
+                        }
+                        : undefined);
+                rule.booleanRule = {
+                    format: format ?? {},
+                    ...(condition ? { condition } : {}),
+                };
+            }
+            rules.push(rule);
+        }
+    }
+    return rules;
+}
+// `calcext:formatting-entry value="X" type="Y"` → engine threshold. ODS
+// uses `value`/`percent`/`percentile`/`auto-minimum`/`auto-maximum`/`formula`;
+// we map onto the engine's enum that XLSX also produces.
+function mapCalcextEntryType(rawType) {
+    switch ((rawType ?? "").toLowerCase()) {
+        case "auto-minimum":
+            return "MIN";
+        case "auto-maximum":
+            return "MAX";
+        case "value":
+        case "number":
+            return "NUMBER";
+        case "percent":
+            return "PERCENT";
+        case "percentile":
+            return "PERCENTILE";
+        case "formula":
+            return "FORMULA";
+        default:
+            return "NUMBER";
+    }
+}
+function parseCalcextFormattingEntries(parentNode, toArray, getAttributes) {
+    const entries = toArray(get(parentNode, "calcext:formatting-entry") ||
+        get(parentNode, "formatting-entry"));
+    const result = [];
+    for (const entry of entries) {
+        const a = getAttributes(entry);
+        if (!a)
+            continue;
+        const type = mapCalcextEntryType(a["@_calcext:type"] || a["@_type"]);
+        const value = a["@_calcext:value"] ?? a["@_value"];
+        result.push({
+            type,
+            ...(value !== undefined ? { value: String(value) } : {}),
+        });
+    }
+    return result;
+}
+// LibreOffice writes the same `calcext:icon-set-type` enum values as OOXML
+// (3Arrows, 3TrafficLights1, ...). The unknown-fallback path defaults to the
+// traffic-lights family which is the most universally recognized.
+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 parseCalcextIconSet(node, getAttributes, toArray) {
+    const attrs = getAttributes(node);
+    const rawFamily = attrs?.["@_calcext:icon-set-type"] ?? attrs?.["@_icon-set-type"];
+    const family = (KNOWN_ICON_SET_FAMILIES.has(rawFamily) ? rawFamily : "3TrafficLights1");
+    const thresholds = parseCalcextFormattingEntries(node, toArray, getAttributes);
+    // Strip the leading "auto-minimum"/"0%" stop that ODS writes for parity
+    // with OOXML — the engine model only carries (icon-count - 1) thresholds.
+    const effective = thresholds.length > 1 ? thresholds.slice(1) : thresholds;
+    return { iconSet: family, thresholds: effective };
+}
+function parseCalcextDataBar(node, getAttributes, toArray) {
+    const attrs = getAttributes(node);
+    const cfvos = parseCalcextFormattingEntries(node, toArray, getAttributes);
+    if (cfvos.length < 2)
+        return null;
+    const positiveColor = attrs?.["@_calcext:positive-color"] ||
+        attrs?.["@_positive-color"] ||
+        "#638ec6";
+    const negativeColor = attrs?.["@_calcext:negative-color"] || attrs?.["@_negative-color"];
+    const rule = {
+        minpoint: cfvos[0],
+        maxpoint: cfvos[cfvos.length - 1],
+        color: positiveColor,
+    };
+    if (negativeColor)
+        rule.negativeColor = negativeColor;
+    return rule;
+}
+function extractStyleNameFromConditions(conditionNodes, getAttributes) {
+    for (const node of conditionNodes) {
+        const attrs = getAttributes(node);
+        if (!attrs)
+            continue;
+        const styleName = attrs["@_calcext:apply-style-name"] ||
+            attrs["@_table:apply-style-name"] ||
+            attrs["@_style:apply-style-name"] ||
+            attrs["@_table:style-name"] ||
+            attrs["@_style-name"];
+        if (styleName)
+            return styleName;
+    }
+    return undefined;
+}
+function extractConditionExpression(conditionNodes, getAttributes) {
+    for (const node of conditionNodes) {
+        const attrs = getAttributes(node);
+        if (!attrs)
+            continue;
+        const condition = attrs["@_calcext:value"] ||
+            attrs["@_table:condition"] ||
+            attrs["@_condition"] ||
+            extractText(node);
+        if (condition)
+            return condition;
+    }
+    return undefined;
+}
+function extractCalcextConditionValue(conditionNodes, getAttributes) {
+    for (const node of conditionNodes) {
+        const attrs = getAttributes(node);
+        if (!attrs)
+            continue;
+        const value = attrs["@_calcext:value"];
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function extractCalcextBaseAddress(conditionNodes, getAttributes) {
+    for (const node of conditionNodes) {
+        const attrs = getAttributes(node);
+        if (!attrs)
+            continue;
+        const address = attrs["@_calcext:base-cell-address"];
+        if (address)
+            return address;
+    }
+    return undefined;
+}
+function extractText(node) {
+    if (!node)
+        return undefined;
+    if (typeof node === "string")
+        return node;
+    if (Array.isArray(node)) {
+        for (const entry of node) {
+            const text = extractText(entry);
+            if (text)
+                return text;
+        }
+        return undefined;
+    }
+    return node["#text"] || node["@_text"] || node._;
+}
+function parseCalcextCondition(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const literalMatch = trimmed.match(/^=\s*"([\s\S]*)"\s*$/);
+    if (literalMatch) {
+        const literalValue = literalMatch[1].replace(/""/g, '"');
+        return {
+            type: "TEXT_EQ",
+            values: [{ userEnteredValue: literalValue }],
+        };
+    }
+    const fnMatch = trimmed.match(/^([a-z-]+)\((.*)\)$/i);
+    if (!fnMatch) {
+        return createCustomFormulaCondition(trimmed);
+    }
+    const fnName = fnMatch[1].toLowerCase();
+    const args = splitTopLevelCommaSeparated(fnMatch[2]).map((arg) => normalizeCalcextArgument(arg));
+    const toValues = (count) => args.slice(0, count).map((arg) => ({ userEnteredValue: arg }));
+    switch (fnName) {
+        case "between":
+            if (args.length >= 2) {
+                return { type: "NUMBER_BETWEEN", values: toValues(2) };
+            }
+            break;
+        case "not-between":
+            if (args.length >= 2) {
+                return { type: "NUMBER_NOT_BETWEEN", values: toValues(2) };
+            }
+            break;
+        case "equal":
+            if (args.length >= 1) {
+                return { type: "NUMBER_EQ", values: toValues(1) };
+            }
+            break;
+        case "not-equal":
+            if (args.length >= 1) {
+                return { type: "NUMBER_NOT_EQ", values: toValues(1) };
+            }
+            break;
+        case "greater-than":
+            if (args.length >= 1) {
+                return { type: "NUMBER_GREATER", values: toValues(1) };
+            }
+            break;
+        case "greater-than-equal":
+            if (args.length >= 1) {
+                return { type: "NUMBER_GREATER_THAN_EQ", values: toValues(1) };
+            }
+            break;
+        case "less-than":
+            if (args.length >= 1) {
+                return { type: "NUMBER_LESS", values: toValues(1) };
+            }
+            break;
+        case "less-than-equal":
+            if (args.length >= 1) {
+                return { type: "NUMBER_LESS_THAN_EQ", values: toValues(1) };
+            }
+            break;
+        case "contains-text":
+            if (args.length >= 1) {
+                return { type: "TEXT_CONTAINS", values: toValues(1) };
+            }
+            break;
+        case "not-contains-text":
+            if (args.length >= 1) {
+                return { type: "TEXT_NOT_CONTAINS", values: toValues(1) };
+            }
+            break;
+        case "begins-with":
+            if (args.length >= 1) {
+                return { type: "TEXT_STARTS_WITH", values: toValues(1) };
+            }
+            break;
+        case "ends-with":
+            if (args.length >= 1) {
+                return { type: "TEXT_ENDS_WITH", values: toValues(1) };
+            }
+            break;
+        case "formula-is":
+            return createCustomFormulaCondition(args[0] ?? "");
+        default:
+            break;
+    }
+    return createCustomFormulaCondition(trimmed);
+}
+function createCustomFormulaCondition(expression) {
+    if (!expression)
+        return undefined;
+    let normalized = convertOdsFormulaToExcel(expression).trim();
+    if (!normalized)
+        return undefined;
+    if (!normalized.startsWith("=")) {
+        normalized = `=${normalized}`;
+    }
+    return {
+        type: "CUSTOM_FORMULA",
+        values: [{ userEnteredValue: normalized }],
+    };
+}
+function splitTopLevelCommaSeparated(value) {
+    const result = [];
+    let depth = 0;
+    let current = "";
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (char === "(") {
+            depth++;
+        }
+        else if (char === ")") {
+            depth = Math.max(0, depth - 1);
+        }
+        if (char === "," && depth === 0) {
+            result.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    if (current) {
+        result.push(current);
+    }
+    return result;
+}
+function normalizeCalcextArgument(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return "";
+    const withoutQuotes = stripWrappingQuotes(trimmed);
+    return convertOdsFormulaToExcel(withoutQuotes).trim();
+}
+function stripWrappingQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.substring(1, value.length - 1);
+    }
+    return value;
+}

package/dist/esm/excel-parser/plugins/ods/data-validations.d.ts

@@ -0,0 +1,15 @@
+import type { DataValidationRuleRecord, SheetRange } from "@rowsncolumns/spreadsheet";
+import type { SheetContext, ToArrayFn } from "./types";
+export type DataValidationExtractionContext = {
+    sheetContexts: SheetContext[];
+    sheetNameMap: Map<string, number>;
+    spreadsheetNode: any;
+    getAttributes: (node: any) => any;
+    parseRangeList: (addresses: string | undefined, sheetNameMap: Map<string, number>, context?: SheetContext) => SheetRange[];
+    normalizeConditionExpression: (expression?: string) => string | undefined;
+    parseBooleanAttribute: (value?: string | boolean) => boolean | undefined;
+    mapAlertStyle: (value?: string) => "stop" | "warning" | "information" | undefined;
+    toArray: ToArrayFn;
+};
+export declare function extractDataValidations(ctx: DataValidationExtractionContext): DataValidationRuleRecord[];
+//# sourceMappingURL=data-validations.d.ts.map

package/dist/esm/excel-parser/plugins/ods/data-validations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-validations.d.ts","sourceRoot":"","sources":["../../../../../excel-parser/plugins/ods/data-validations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,wBAAwB,EACxB,UAAU,EACX,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEvD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,eAAe,EAAE,GAAG,CAAC;IACrB,aAAa,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;IAClC,cAAc,EAAE,CACd,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,OAAO,CAAC,EAAE,YAAY,KACnB,UAAU,EAAE,CAAC;IAClB,4BAA4B,EAAE,CAAC,UAAU,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IAC1E,qBAAqB,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,KAAK,OAAO,GAAG,SAAS,CAAC;IACzE,aAAa,EAAE,CACb,KAAK,CAAC,EAAE,MAAM,KACX,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAAC;IACpD,OAAO,EAAE,SAAS,CAAC;CACpB,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,+BAA+B,GACnC,wBAAwB,EAAE,CAuI5B"}