@rowsncolumns/toolkit 24.4.1

package/dist/esm/excel-parser/plugins/xlsx/data-validations.js

@@ -0,0 +1,493 @@
+import { addressToSelection, checkIfStringIsReference, cellToAddress, } from "@rowsncolumns/utils";
+import { uuid } from "@rowsncolumns/utils";
+import { get } from "lodash-es";
+const formatSheetName = (sheetName) => {
+    if (!sheetName) {
+        return "";
+    }
+    return `'${sheetName.replace(/'/g, "''")}'`;
+};
+const ensureSheetReference = (reference, sheetName) => {
+    if (!sheetName || reference.includes("!")) {
+        return reference;
+    }
+    const prefix = formatSheetName(sheetName);
+    return `${prefix}!${reference}`;
+};
+const extractFormulaText = (entry) => {
+    if (entry === undefined || entry === null) {
+        return undefined;
+    }
+    if (typeof entry === "string" || typeof entry === "number") {
+        return String(entry);
+    }
+    if (typeof entry === "object") {
+        if (typeof entry.t$ === "string") {
+            return entry.t$;
+        }
+        if (typeof entry._ === "string") {
+            return entry._;
+        }
+        if (typeof entry["#text"] === "string") {
+            return entry["#text"];
+        }
+    }
+    return undefined;
+};
+const normalizeFormulaText = (entry) => {
+    const text = extractFormulaText(entry);
+    if (text === undefined) {
+        return undefined;
+    }
+    const trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
+};
+const normalizeOperator = (operator, hasSecondValue) => operator || (hasSecondValue ? "between" : "equal");
+const mapNumberOperatorToCondition = (operator, hasSecondValue) => {
+    const normalized = normalizeOperator(operator, hasSecondValue);
+    const operatorMap = {
+        between: "NUMBER_BETWEEN",
+        notBetween: "NUMBER_NOT_BETWEEN",
+        equal: "NUMBER_EQ",
+        notEqual: "NUMBER_NOT_EQ",
+        greaterThan: "NUMBER_GREATER",
+        greaterThanOrEqual: "NUMBER_GREATER_THAN_EQ",
+        lessThan: "NUMBER_LESS",
+        lessThanOrEqual: "NUMBER_LESS_THAN_EQ",
+    };
+    return operatorMap[normalized];
+};
+const mapDateOperatorToCondition = (operator, hasSecondValue) => {
+    const normalized = normalizeOperator(operator, hasSecondValue);
+    const operatorMap = {
+        between: "DATE_BETWEEN",
+        notBetween: "DATE_NOT_BETWEEN",
+        equal: "DATE_EQ",
+        notEqual: "DATE_NOT_EQ",
+        greaterThan: "DATE_AFTER",
+        greaterThanOrEqual: "DATE_ON_OR_AFTER",
+        lessThan: "DATE_BEFORE",
+        lessThanOrEqual: "DATE_ON_OR_BEFORE",
+    };
+    return operatorMap[normalized];
+};
+const buildTextLengthFormula = (operator, baseCellRef, fromExpr, toExpr) => {
+    const lenExpr = `LEN(${baseCellRef})`;
+    const normalized = normalizeOperator(operator, Boolean(toExpr));
+    if (!fromExpr && normalized !== "between" && normalized !== "notBetween") {
+        return undefined;
+    }
+    switch (normalized) {
+        case "between":
+            if (!fromExpr || !toExpr)
+                return undefined;
+            return `AND(${lenExpr}>=${fromExpr},${lenExpr}<=${toExpr})`;
+        case "notBetween":
+            if (!fromExpr || !toExpr)
+                return undefined;
+            return `OR(${lenExpr}<${fromExpr},${lenExpr}>${toExpr})`;
+        case "equal":
+            return `${lenExpr}=${fromExpr}`;
+        case "notEqual":
+            return `${lenExpr}<>${fromExpr}`;
+        case "greaterThan":
+            return `${lenExpr}>${fromExpr}`;
+        case "greaterThanOrEqual":
+            return `${lenExpr}>=${fromExpr}`;
+        case "lessThan":
+            return `${lenExpr}<${fromExpr}`;
+        case "lessThanOrEqual":
+            return `${lenExpr}<=${fromExpr}`;
+        default:
+            return undefined;
+    }
+};
+const mapErrorStyle = (style) => {
+    if (!style)
+        return "stop";
+    if (style === "warning")
+        return "warning";
+    if (style === "information")
+        return "information";
+    return "stop";
+};
+const NUMBER_VALIDATION_TYPES = new Set(["whole", "decimal", "time"]);
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const parseListValues = (raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    return [parseTextLiteral(trimmed)];
+};
+const parseTextLiteral = (raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).replace(/""/g, '"');
+    }
+    return trimmed;
+};
+const parseCustomValidationFormula = (rawFormula, baseCellRef) => {
+    const formula = rawFormula.trim().startsWith("=")
+        ? rawFormula.trim().slice(1)
+        : rawFormula.trim();
+    if (!formula)
+        return undefined;
+    const baseMatch = /^([A-Z]+)(\d+)$/i.exec(baseCellRef);
+    const baseRefPattern = baseMatch
+        ? `\\$?${baseMatch[1]}\\$?${baseMatch[2]}`
+        : escapeRegExp(baseCellRef);
+    const basePattern = `(?:${baseRefPattern}|INDIRECT\\("RC",FALSE\\))`;
+    const textContains = new RegExp(`^ISNUMBER\\(SEARCH\\((.+),\\s*${basePattern}\\)\\)$`, "i");
+    const textNotContains = new RegExp(`^ISERROR\\(SEARCH\\((.+),\\s*${basePattern}\\)\\)$`, "i");
+    const textStartsWith = new RegExp(`^LEFT\\(${basePattern},LEN\\((.+)\\)\\)=(.+)$`, "i");
+    const textEndsWith = new RegExp(`^RIGHT\\(${basePattern},LEN\\((.+)\\)\\)=(.+)$`, "i");
+    const textIsEmail = new RegExp(`^AND\\(ISNUMBER\\(SEARCH\\("@",${basePattern}\\)\\),ISNUMBER\\(SEARCH\\("\\.",${basePattern}\\)\\)\\)$`, "i");
+    const textIsUrl = new RegExp(`^OR\\(LEFT\\(${basePattern},7\\)="http://",LEFT\\(${basePattern},8\\)="https://"\\)$`, "i");
+    const blank = new RegExp(`^${basePattern}=""$`, "i");
+    const notBlank = new RegExp(`^${basePattern}<>""$`, "i");
+    const boolean = new RegExp(`^OR\\(${basePattern}=TRUE,${basePattern}=FALSE\\)$`, "i");
+    const dateIsValid = new RegExp(`^ISNUMBER\\(${basePattern}\\)$`, "i");
+    const previousNumber = new RegExp(`^IFERROR\\(${basePattern}\\s*(>=|<=|>|<)\\s*INDIRECT\\("R\\[-1\\]C",FALSE\\),TRUE\\)$`, "i");
+    const oneOfRange = new RegExp(`^COUNTIF\\((.+),\\s*${basePattern}\\)\\s*>\\s*0$`, "i");
+    const oneOfList = new RegExp(`^OR\\((.+)\\)$`, "i");
+    let match = formula.match(textContains);
+    if (match) {
+        const value = parseTextLiteral(match[1]);
+        return value
+            ? { type: "TEXT_CONTAINS", values: [{ userEnteredValue: value }] }
+            : undefined;
+    }
+    match = formula.match(textNotContains);
+    if (match) {
+        const value = parseTextLiteral(match[1]);
+        return value
+            ? { type: "TEXT_NOT_CONTAINS", values: [{ userEnteredValue: value }] }
+            : undefined;
+    }
+    match = formula.match(textStartsWith);
+    if (match) {
+        const value = parseTextLiteral(match[1]);
+        return value
+            ? { type: "TEXT_STARTS_WITH", values: [{ userEnteredValue: value }] }
+            : undefined;
+    }
+    match = formula.match(textEndsWith);
+    if (match) {
+        const value = parseTextLiteral(match[1]);
+        return value
+            ? { type: "TEXT_ENDS_WITH", values: [{ userEnteredValue: value }] }
+            : undefined;
+    }
+    if (textIsEmail.test(formula)) {
+        return { type: "TEXT_IS_EMAIL", values: [] };
+    }
+    if (textIsUrl.test(formula)) {
+        return { type: "TEXT_IS_URL", values: [] };
+    }
+    if (blank.test(formula)) {
+        return { type: "BLANK", values: [] };
+    }
+    if (notBlank.test(formula)) {
+        return { type: "NOT_BLANK", values: [] };
+    }
+    if (boolean.test(formula)) {
+        return { type: "BOOLEAN", values: [] };
+    }
+    if (dateIsValid.test(formula)) {
+        return { type: "DATE_IS_VALID", values: [] };
+    }
+    match = formula.match(previousNumber);
+    if (match) {
+        const op = match[1];
+        const opMap = {
+            ">": "NUMBER_GREATER_THAN_PREVIOUS",
+            ">=": "NUMBER_GREATER_THAN_EQ_PREVIOUS",
+            "<": "NUMBER_LESS_THAN_PREVIOUS",
+            "<=": "NUMBER_LESS_THAN_EQ_PREVIOUS",
+        };
+        const type = opMap[op];
+        return type ? { type, values: [] } : undefined;
+    }
+    match = formula.match(oneOfRange);
+    if (match) {
+        const rangeRef = match[1].trim();
+        return rangeRef
+            ? { type: "ONE_OF_RANGE", values: [{ userEnteredValue: rangeRef }] }
+            : undefined;
+    }
+    match = formula.match(oneOfList);
+    if (match) {
+        const entries = [];
+        const entryRegex = new RegExp(`${basePattern}\\s*=\\s*([^,\\)]+)`, "gi");
+        let entryMatch;
+        while ((entryMatch = entryRegex.exec(match[1]))) {
+            const value = parseTextLiteral(entryMatch[1]);
+            if (value) {
+                entries.push({ userEnteredValue: value });
+            }
+        }
+        if (entries.length) {
+            return { type: "ONE_OF_LIST", values: entries };
+        }
+    }
+    return undefined;
+};
+export const getDataValidationsForSheet = (workbook, sheetId, sheet_data, sheetName) => {
+    const dataValidations = [];
+    // Handle both with and without namespace prefix
+    const validation = get(sheet_data, "worksheet.dataValidations.dataValidation") ||
+        get(sheet_data, "x:worksheet.x:dataValidations.x:dataValidation") ||
+        [];
+    const validations = Array.isArray(validation) ? validation : [validation];
+    // x14 (worksheet-extLst) validations — what Excel writes when a list rule's
+    // source lives on ANOTHER sheet. Ranges arrive via the `<xm:sqref>` CHILD
+    // (not the classic `sqref` attribute) and formulas via
+    // `<x14:formula1>/<xm:f>`. Normalize each into the classic node shape so
+    // the mapping loop below handles both forms identically.
+    const extEntry = get(sheet_data, "worksheet.extLst.ext") ||
+        get(sheet_data, "x:worksheet.x:extLst.x:ext") ||
+        [];
+    const exts = Array.isArray(extEntry) ? extEntry : [extEntry];
+    const x14Rules = exts
+        .flatMap((ext) => {
+        const block = get(ext, "x14:dataValidations.x14:dataValidation") ||
+            get(ext, "dataValidations.dataValidation");
+        return block ? (Array.isArray(block) ? block : [block]) : [];
+    })
+        .map((node) => {
+        const sqrefEntry = node?.["xm:sqref"] ?? node?.sqref;
+        const sqref = (Array.isArray(sqrefEntry) ? sqrefEntry : [sqrefEntry])
+            .map((entry) => extractFormulaText(entry)?.trim())
+            .filter(Boolean)
+            .join(" ");
+        if (!sqref) {
+            return undefined;
+        }
+        const formulaText = (formulaNode) => {
+            if (formulaNode === undefined || formulaNode === null) {
+                return undefined;
+            }
+            return extractFormulaText(formulaNode?.["xm:f"] ?? formulaNode?.f ?? formulaNode);
+        };
+        return {
+            a$: { ...(node?.a$ ?? {}), sqref },
+            formula1: formulaText(node?.["x14:formula1"] ?? node?.formula1),
+            formula2: formulaText(node?.["x14:formula2"] ?? node?.formula2),
+        };
+    })
+        .filter(Boolean);
+    const namedRanges = workbook.getNamedRanges();
+    for (const rule of [...validations, ...x14Rules]) {
+        if (!rule?.a$?.sqref) {
+            continue;
+        }
+        const sqref = rule.a$.sqref.split(" ");
+        const type = rule.a$.type;
+        const ranges = [];
+        for (const ref of sqref) {
+            const range = addressToSelection(ref)?.range;
+            if (range) {
+                ranges.push({
+                    sheetId,
+                    ...range,
+                });
+            }
+        }
+        if (!ranges.length) {
+            continue;
+        }
+        const baseCellRef = cellToAddress({
+            rowIndex: ranges[0].startRowIndex,
+            columnIndex: ranges[0].startColumnIndex,
+        }) ?? "A1";
+        const allowBlank = rule.a$.allowBlank === "1";
+        const showInputMessage = rule.a$.showInputMessage === "1";
+        const showErrorMessage = rule.a$.showErrorMessage === "1";
+        const inputMessage = showInputMessage && (rule.a$.prompt || rule.a$.promptTitle)
+            ? {
+                title: rule.a$.promptTitle ?? undefined,
+                message: rule.a$.prompt ?? undefined,
+            }
+            : undefined;
+        // showErrorMessage alone (no custom title/text) still means "reject
+        // invalid input with Excel's default alert" — keep the alert with just
+        // its style so the Stop/Warning behavior survives import.
+        const alert = showErrorMessage
+            ? {
+                style: mapErrorStyle(rule.a$.errorStyle),
+                message: rule.a$.error || rule.a$.errorTitle
+                    ? {
+                        title: rule.a$.errorTitle ?? undefined,
+                        message: rule.a$.error ?? undefined,
+                    }
+                    : undefined,
+            }
+            : undefined;
+        // Prompt-only DV: Excel's "input message" feature attaches a tooltip
+        // (and/or an error alert) to a cell range without any validation
+        // constraint. These have no `type` attribute. Preserve them so the
+        // tooltip survives the round-trip.
+        if (!type) {
+            if (inputMessage || alert) {
+                dataValidations.push({
+                    id: uuid(),
+                    ranges,
+                    allowBlank,
+                    inputMessage,
+                    alert,
+                });
+            }
+            continue;
+        }
+        const formula1Node = rule.formula1 ?? rule["x:formula1"];
+        const formula2Node = rule.formula2 ?? rule["x:formula2"];
+        // Capture the source xlsx representation verbatim so the exporter can
+        // round-trip the original `type`/`operator`/formulas instead of
+        // re-synthesizing from the parsed `condition` (which loses fidelity:
+        // `whole` collapses to `decimal`, `textLength` collapses to `custom`,
+        // user formulas get `INDIRECT("RC",FALSE)` rewriting). The source
+        // formula text is kept with any leading `=` stripped (matches xlsx wire
+        // format — `<formula1>` carries the expression without `=`).
+        const formula1Verbatim = (() => {
+            const text = extractFormulaText(formula1Node);
+            if (text === undefined)
+                return undefined;
+            const trimmed = String(text).trim();
+            if (!trimmed)
+                return undefined;
+            return trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
+        })();
+        const formula2Verbatim = (() => {
+            const text = extractFormulaText(formula2Node);
+            if (text === undefined)
+                return undefined;
+            const trimmed = String(text).trim();
+            if (!trimmed)
+                return undefined;
+            return trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
+        })();
+        const xlsxSource = {
+            type,
+            ...(rule.a$.operator ? { operator: rule.a$.operator } : {}),
+            ...(formula1Verbatim !== undefined
+                ? { formula1: formula1Verbatim }
+                : {}),
+            ...(formula2Verbatim !== undefined
+                ? { formula2: formula2Verbatim }
+                : {}),
+        };
+        if (type === "list") {
+            const rawFormula = extractFormulaText(formula1Node) ?? "";
+            const trimmedFormula = String(rawFormula ?? "").trim();
+            const referenceCandidate = trimmedFormula.startsWith("=")
+                ? trimmedFormula.slice(1)
+                : trimmedFormula;
+            const isOffsetFormula = /^offset\(/i.test(referenceCandidate);
+            const isNamedRange = !!namedRanges.find((n) => n.name === referenceCandidate);
+            const listValues = parseListValues(trimmedFormula);
+            const isRef = checkIfStringIsReference(referenceCandidate) ||
+                isOffsetFormula ||
+                isNamedRange;
+            const normalizedReference = isRef && !isNamedRange
+                ? ensureSheetReference(referenceCandidate, sheetName)
+                : referenceCandidate;
+            const values = isRef
+                ? [
+                    {
+                        userEnteredValue: normalizedReference.startsWith("=")
+                            ? normalizedReference
+                            : `=${normalizedReference}`,
+                    },
+                ]
+                : listValues.map((value) => ({ userEnteredValue: value }));
+            if (!values.length) {
+                values.push({ userEnteredValue: trimmedFormula });
+            }
+            dataValidations.push({
+                id: uuid(),
+                ranges,
+                condition: {
+                    type: isRef ? "ONE_OF_RANGE" : "ONE_OF_LIST",
+                    values,
+                },
+                allowBlank,
+                displayStyle: rule.a$.showDropDown === "1" ? "plain" : undefined,
+                inputMessage,
+                alert,
+                xlsxSource,
+            });
+            continue;
+        }
+        const formula1 = normalizeFormulaText(formula1Node);
+        const formula2 = normalizeFormulaText(formula2Node);
+        if (type === "custom") {
+            if (!formula1) {
+                continue;
+            }
+            const parsedCondition = parseCustomValidationFormula(formula1, baseCellRef);
+            dataValidations.push({
+                id: uuid(),
+                ranges,
+                condition: parsedCondition ?? {
+                    type: "CUSTOM_FORMULA",
+                    values: [{ userEnteredValue: formula1 }],
+                },
+                allowBlank,
+                inputMessage,
+                alert,
+                xlsxSource,
+            });
+            continue;
+        }
+        if (type === "textLength") {
+            const lengthFormula = buildTextLengthFormula(rule.a$.operator, baseCellRef, formula1, formula2);
+            if (!lengthFormula) {
+                continue;
+            }
+            dataValidations.push({
+                id: uuid(),
+                ranges,
+                condition: {
+                    type: "CUSTOM_FORMULA",
+                    values: [{ userEnteredValue: lengthFormula }],
+                },
+                allowBlank,
+                inputMessage,
+                alert,
+                xlsxSource,
+            });
+            continue;
+        }
+        const isDateType = type === "date";
+        if (!isDateType && !NUMBER_VALIDATION_TYPES.has(type)) {
+            continue;
+        }
+        const conditionType = isDateType
+            ? mapDateOperatorToCondition(rule.a$.operator, Boolean(formula2))
+            : mapNumberOperatorToCondition(rule.a$.operator, Boolean(formula2));
+        if (!conditionType || !formula1) {
+            continue;
+        }
+        const values = [
+            { userEnteredValue: formula1 },
+            ...(formula2 ? [{ userEnteredValue: formula2 }] : []),
+        ];
+        dataValidations.push({
+            id: uuid(),
+            ranges,
+            condition: {
+                type: conditionType,
+                values,
+            },
+            allowBlank,
+            inputMessage,
+            alert,
+            xlsxSource,
+        });
+    }
+    return dataValidations;
+};

package/dist/esm/excel-parser/plugins/xlsx/drawing.d.ts

@@ -0,0 +1,39 @@
+import type { EmbeddedObject, EmbedShapeSpec } from "@rowsncolumns/spreadsheet";
+import { type XMLParser } from "fast-xml-parser";
+import { type StreamingZipParser } from "../../zip-parser-streaming";
+export type EmbeddedObjectWithPosition = EmbeddedObject & {
+    isInsideCell?: boolean;
+};
+/**
+ * Process different types of image anchors
+ * @param anchors The anchor elements from the drawing
+ * @param anchorType The type of anchor
+ * @param drawingPath The path to the drawing file
+ * @param sheetName The name of the worksheet
+ * @param zipParser The zip parser instance
+ * @param xmlParser The XML parser instance
+ * @returns An array of image objects with their properties and binary data
+ */
+export declare function processAnchors(anchors: any, anchorType: string, drawingPath: string, sheetId: number, zipParser: StreamingZipParser, xmlParser: XMLParser): Promise<EmbeddedObjectWithPosition[]>;
+/**
+ * Whether an `<xdr:sp>` should import as a drawing shape (`EmbedShapeSpec`)
+ * rather than a textbox. Text boxes are excluded explicitly (`txBox="1"`), and
+ * a rect with no `<xdr:style>` block stays a textbox too — routing those to
+ * the shape renderer would repaint plain text notes with the default accent
+ * shape style.
+ */
+export declare function isDrawingShape(shape: any): boolean;
+/** Parse an `<xdr:sp>` drawing shape into an {@link EmbedShapeSpec}. */
+export declare function parseShapeSpec(shape: any): EmbedShapeSpec;
+/**
+ * Determine if a oneCellAnchor image is inside a cell
+ * Using EMU values for accurate assessment
+ * @param fromColOff Column offset in EMUs
+ * @param fromRowOff Row offset in EMUs
+ * @param fLocksWithSheet Whether image locks with sheet
+ * @param cx Image width in EMUs
+ * @param cy Image height in EMUs
+ * @returns Boolean indicating if the image is inside a cell
+ */
+export declare function determineIfOneCellInsideCell(fromColOff: number, fromRowOff: number, fLocksWithSheet: string, cx: number, cy: number): boolean;
+//# sourceMappingURL=drawing.d.ts.map

package/dist/esm/excel-parser/plugins/xlsx/drawing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing.d.ts","sourceRoot":"","sources":["../../../../../excel-parser/plugins/xlsx/drawing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EAEd,cAAc,EAWf,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAoDrE,MAAM,MAAM,0BAA0B,GAAG,cAAc,GAAG;IACxD,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,GAAG,EACZ,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,kBAAkB,EAC7B,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,0BAA0B,EAAE,CAAC,CA6dvC;AA6OD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CASlD;AAED,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,GAAG,cAAc,CA8CzD;AA8MD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,MAAM,EACvB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,OAAO,CAqBT"}