@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,488 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { get } from "lodash-es";
+import { convertOdsFormulaToExcel } from "./formula";
+export function extractConditionalFormats(ctx) {
+    var e_1, _a, e_2, _b;
+    var sheetContexts = ctx.sheetContexts, sheetNameMap = ctx.sheetNameMap, odsStyles = ctx.odsStyles, getAttributes = ctx.getAttributes, parseRangeList = ctx.parseRangeList, normalizeExpression = ctx.normalizeExpression, normalizeConditionExpression = ctx.normalizeConditionExpression, toArray = ctx.toArray;
+    if (!sheetContexts.length)
+        return [];
+    var rules = [];
+    var ruleCounter = 1;
+    try {
+        for (var sheetContexts_1 = __values(sheetContexts), sheetContexts_1_1 = sheetContexts_1.next(); !sheetContexts_1_1.done; sheetContexts_1_1 = sheetContexts_1.next()) {
+            var context = sheetContexts_1_1.value;
+            var conditionNodes = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(toArray(get(context.node, "table:table-conditional-format"))), false), __read(toArray(get(context.node, "table:table-conditional-formats.table:table-conditional-format"))), false), __read(toArray(get(context.node, "table-conditional-format"))), false), __read(toArray(get(context.node, "calcext:conditional-formats.calcext:conditional-format"))), false), __read(toArray(get(context.node, "calcext:conditional-format"))), false);
+            try {
+                for (var conditionNodes_1 = (e_2 = void 0, __values(conditionNodes)), conditionNodes_1_1 = conditionNodes_1.next(); !conditionNodes_1_1.done; conditionNodes_1_1 = conditionNodes_1.next()) {
+                    var node = conditionNodes_1_1.value;
+                    var attrs = getAttributes(node);
+                    if (!attrs)
+                        continue;
+                    var iconSetNode = get(node, "calcext:icon-set") || get(node, "icon-set");
+                    var dataBarNode = get(node, "calcext:data-bar") || get(node, "data-bar");
+                    var nestedConditions = toArray(get(node, "table:condition") ||
+                        get(node, "condition") ||
+                        get(node, "calcext:condition"));
+                    var baseAddressAttr = attrs["@_calcext:base-cell-address"] ||
+                        extractCalcextBaseAddress(nestedConditions, getAttributes);
+                    var 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;
+                    var nestedStyleName = extractStyleNameFromConditions(nestedConditions, getAttributes);
+                    var styleName = nestedStyleName ||
+                        attrs["@_calcext:apply-style-name"] ||
+                        attrs["@_table:apply-style-name"] ||
+                        attrs["@_table:style-name"] ||
+                        attrs["@_style:apply-style-name"];
+                    var stopIfTrueAttr = attrs["@_calcext:stop-if-true"] ||
+                        attrs["@_table:stop-if-true"] ||
+                        attrs["@_stop-if-true"];
+                    var format = styleName ? odsStyles.getStyle(styleName) : undefined;
+                    var calcextConditionValue = attrs["@_calcext:value"] ||
+                        extractCalcextConditionValue(nestedConditions, getAttributes);
+                    var rawCondition = attrs["@_table:condition"] ||
+                        attrs["@_condition"] ||
+                        extractConditionExpression(nestedConditions, getAttributes);
+                    var parsedCalcextCondition = parseCalcextCondition(calcextConditionValue);
+                    var 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;
+                    }
+                    var priority = ruleCounter++;
+                    var rule = {
+                        id: "ods-cf-".concat(context.sheetId, "-").concat(priority),
+                        ranges: ranges,
+                        priority: priority,
+                    };
+                    if (stopIfTrueAttr === "true" || stopIfTrueAttr === "1") {
+                        rule.stopIfTrue = true;
+                    }
+                    if (iconSetNode) {
+                        var parsed = parseCalcextIconSet(iconSetNode, getAttributes, toArray);
+                        if (parsed) {
+                            rule.iconSetRule = parsed;
+                            rules.push(rule);
+                            continue;
+                        }
+                    }
+                    if (dataBarNode) {
+                        var parsed = parseCalcextDataBar(dataBarNode, getAttributes, toArray);
+                        if (parsed) {
+                            rule.dataBarRule = parsed;
+                            rules.push(rule);
+                            continue;
+                        }
+                    }
+                    if (format || formula || parsedCalcextCondition) {
+                        var condition = parsedCalcextCondition ||
+                            (formula
+                                ? {
+                                    type: "CUSTOM_FORMULA",
+                                    values: [{ userEnteredValue: formula }],
+                                }
+                                : undefined);
+                        rule.booleanRule = __assign({ format: format !== null && format !== void 0 ? format : {} }, (condition ? { condition: condition } : {}));
+                    }
+                    rules.push(rule);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (conditionNodes_1_1 && !conditionNodes_1_1.done && (_b = conditionNodes_1.return)) _b.call(conditionNodes_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (sheetContexts_1_1 && !sheetContexts_1_1.done && (_a = sheetContexts_1.return)) _a.call(sheetContexts_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    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 !== null && rawType !== void 0 ? 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) {
+    var e_3, _a;
+    var _b;
+    var entries = toArray(get(parentNode, "calcext:formatting-entry") ||
+        get(parentNode, "formatting-entry"));
+    var result = [];
+    try {
+        for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+            var entry = entries_1_1.value;
+            var a = getAttributes(entry);
+            if (!a)
+                continue;
+            var type = mapCalcextEntryType(a["@_calcext:type"] || a["@_type"]);
+            var value = (_b = a["@_calcext:value"]) !== null && _b !== void 0 ? _b : a["@_value"];
+            result.push(__assign({ type: type }, (value !== undefined ? { value: String(value) } : {})));
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    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.
+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 parseCalcextIconSet(node, getAttributes, toArray) {
+    var _a;
+    var attrs = getAttributes(node);
+    var rawFamily = (_a = attrs === null || attrs === void 0 ? void 0 : attrs["@_calcext:icon-set-type"]) !== null && _a !== void 0 ? _a : attrs === null || attrs === void 0 ? void 0 : attrs["@_icon-set-type"];
+    var family = (KNOWN_ICON_SET_FAMILIES.has(rawFamily) ? rawFamily : "3TrafficLights1");
+    var 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.
+    var effective = thresholds.length > 1 ? thresholds.slice(1) : thresholds;
+    return { iconSet: family, thresholds: effective };
+}
+function parseCalcextDataBar(node, getAttributes, toArray) {
+    var attrs = getAttributes(node);
+    var cfvos = parseCalcextFormattingEntries(node, toArray, getAttributes);
+    if (cfvos.length < 2)
+        return null;
+    var positiveColor = (attrs === null || attrs === void 0 ? void 0 : attrs["@_calcext:positive-color"]) ||
+        (attrs === null || attrs === void 0 ? void 0 : attrs["@_positive-color"]) ||
+        "#638ec6";
+    var negativeColor = (attrs === null || attrs === void 0 ? void 0 : attrs["@_calcext:negative-color"]) || (attrs === null || attrs === void 0 ? void 0 : attrs["@_negative-color"]);
+    var rule = {
+        minpoint: cfvos[0],
+        maxpoint: cfvos[cfvos.length - 1],
+        color: positiveColor,
+    };
+    if (negativeColor)
+        rule.negativeColor = negativeColor;
+    return rule;
+}
+function extractStyleNameFromConditions(conditionNodes, getAttributes) {
+    var e_4, _a;
+    try {
+        for (var conditionNodes_2 = __values(conditionNodes), conditionNodes_2_1 = conditionNodes_2.next(); !conditionNodes_2_1.done; conditionNodes_2_1 = conditionNodes_2.next()) {
+            var node = conditionNodes_2_1.value;
+            var attrs = getAttributes(node);
+            if (!attrs)
+                continue;
+            var 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;
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (conditionNodes_2_1 && !conditionNodes_2_1.done && (_a = conditionNodes_2.return)) _a.call(conditionNodes_2);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return undefined;
+}
+function extractConditionExpression(conditionNodes, getAttributes) {
+    var e_5, _a;
+    try {
+        for (var conditionNodes_3 = __values(conditionNodes), conditionNodes_3_1 = conditionNodes_3.next(); !conditionNodes_3_1.done; conditionNodes_3_1 = conditionNodes_3.next()) {
+            var node = conditionNodes_3_1.value;
+            var attrs = getAttributes(node);
+            if (!attrs)
+                continue;
+            var condition = attrs["@_calcext:value"] ||
+                attrs["@_table:condition"] ||
+                attrs["@_condition"] ||
+                extractText(node);
+            if (condition)
+                return condition;
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (conditionNodes_3_1 && !conditionNodes_3_1.done && (_a = conditionNodes_3.return)) _a.call(conditionNodes_3);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return undefined;
+}
+function extractCalcextConditionValue(conditionNodes, getAttributes) {
+    var e_6, _a;
+    try {
+        for (var conditionNodes_4 = __values(conditionNodes), conditionNodes_4_1 = conditionNodes_4.next(); !conditionNodes_4_1.done; conditionNodes_4_1 = conditionNodes_4.next()) {
+            var node = conditionNodes_4_1.value;
+            var attrs = getAttributes(node);
+            if (!attrs)
+                continue;
+            var value = attrs["@_calcext:value"];
+            if (value)
+                return value;
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (conditionNodes_4_1 && !conditionNodes_4_1.done && (_a = conditionNodes_4.return)) _a.call(conditionNodes_4);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return undefined;
+}
+function extractCalcextBaseAddress(conditionNodes, getAttributes) {
+    var e_7, _a;
+    try {
+        for (var conditionNodes_5 = __values(conditionNodes), conditionNodes_5_1 = conditionNodes_5.next(); !conditionNodes_5_1.done; conditionNodes_5_1 = conditionNodes_5.next()) {
+            var node = conditionNodes_5_1.value;
+            var attrs = getAttributes(node);
+            if (!attrs)
+                continue;
+            var address = attrs["@_calcext:base-cell-address"];
+            if (address)
+                return address;
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (conditionNodes_5_1 && !conditionNodes_5_1.done && (_a = conditionNodes_5.return)) _a.call(conditionNodes_5);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return undefined;
+}
+function extractText(node) {
+    var e_8, _a;
+    if (!node)
+        return undefined;
+    if (typeof node === "string")
+        return node;
+    if (Array.isArray(node)) {
+        try {
+            for (var node_1 = __values(node), node_1_1 = node_1.next(); !node_1_1.done; node_1_1 = node_1.next()) {
+                var entry = node_1_1.value;
+                var text = extractText(entry);
+                if (text)
+                    return text;
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (node_1_1 && !node_1_1.done && (_a = node_1.return)) _a.call(node_1);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        return undefined;
+    }
+    return node["#text"] || node["@_text"] || node._;
+}
+function parseCalcextCondition(value) {
+    var _a;
+    if (!value)
+        return undefined;
+    var trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    var literalMatch = trimmed.match(/^=\s*"([\s\S]*)"\s*$/);
+    if (literalMatch) {
+        var literalValue = literalMatch[1].replace(/""/g, '"');
+        return {
+            type: "TEXT_EQ",
+            values: [{ userEnteredValue: literalValue }],
+        };
+    }
+    var fnMatch = trimmed.match(/^([a-z-]+)\((.*)\)$/i);
+    if (!fnMatch) {
+        return createCustomFormulaCondition(trimmed);
+    }
+    var fnName = fnMatch[1].toLowerCase();
+    var args = splitTopLevelCommaSeparated(fnMatch[2]).map(function (arg) {
+        return normalizeCalcextArgument(arg);
+    });
+    var toValues = function (count) {
+        return args.slice(0, count).map(function (arg) { return ({ 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((_a = args[0]) !== null && _a !== void 0 ? _a : "");
+        default:
+            break;
+    }
+    return createCustomFormulaCondition(trimmed);
+}
+function createCustomFormulaCondition(expression) {
+    if (!expression)
+        return undefined;
+    var normalized = convertOdsFormulaToExcel(expression).trim();
+    if (!normalized)
+        return undefined;
+    if (!normalized.startsWith("=")) {
+        normalized = "=".concat(normalized);
+    }
+    return {
+        type: "CUSTOM_FORMULA",
+        values: [{ userEnteredValue: normalized }],
+    };
+}
+function splitTopLevelCommaSeparated(value) {
+    var result = [];
+    var depth = 0;
+    var current = "";
+    for (var i = 0; i < value.length; i++) {
+        var 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) {
+    var trimmed = value.trim();
+    if (!trimmed)
+        return "";
+    var 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/cjs/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/cjs/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"}