@cj-tech-master/excelts 9.2.1 → 9.3.0

package/dist/esm/modules/excel/xlsx/xform/sheet/cell-xform.js

@@ -39,6 +39,60 @@ function getEffectiveCellType(cell) {
             return cell.type;
     }
 }
+/**
+ * Extract the display form of a hyperlink cell value that came either from
+ * a shared-string rich-text payload (`{ richText: [...] }`) or from a
+ * plain scalar.
+ *
+ * Input comes from the XML parser (`raw: unknown`), so every nested value is
+ * treated defensively — the public `RichText` shape is only produced after
+ * runtime validation, never asserted.
+ *
+ * Returns:
+ *  - `text`:     always a string (flattened rich-text or `String(raw)`)
+ *  - `richText`: preserved if the source was a rich-text payload, else undefined
+ *
+ * This keeps the CellHyperlinkValue.text: string public contract intact while
+ * also letting the Hyperlink value class retain the formatted runs
+ * (see https://github.com/cjnoname/excelts/issues/142).
+ */
+function extractHyperlinkDisplay(raw) {
+    if (raw === null || raw === undefined) {
+        return { text: "" };
+    }
+    if (typeof raw === "string") {
+        return { text: raw };
+    }
+    if (typeof raw === "number" || typeof raw === "boolean") {
+        return { text: String(raw) };
+    }
+    if (typeof raw === "object") {
+        const obj = raw;
+        if (Array.isArray(obj.richText)) {
+            // Empty runs array carries no content — emit empty display text rather
+            // than falling through to `String(raw)` which would produce
+            // "[object Object]".
+            if (obj.richText.length === 0) {
+                return { text: "" };
+            }
+            const runs = obj.richText.map(rawRun => {
+                const run = rawRun;
+                const normalized = {
+                    text: typeof run?.text === "string" ? run.text : ""
+                };
+                if (run?.font !== null && typeof run?.font === "object") {
+                    normalized.font = run.font;
+                }
+                return normalized;
+            });
+            return { text: runs.map(r => r.text).join(""), richText: runs };
+        }
+        if (typeof obj.error === "string") {
+            return { text: obj.error };
+        }
+    }
+    return { text: String(raw) };
+}
 class CellXform extends BaseXform {
     constructor() {
         super();
@@ -68,8 +122,15 @@ class CellXform extends BaseXform {
                 }
                 break;
             case Enums.ValueType.Hyperlink:
-                if (options.sharedStrings && model.text !== undefined && model.text !== null) {
-                    model.ssId = options.sharedStrings.add(model.text);
+                if (options.sharedStrings) {
+                    // Prefer rich-text payload when present so formatted display
+                    // survives a write. Fall back to plain text otherwise.
+                    if (Array.isArray(model.richText) && model.richText.length > 0) {
+                        model.ssId = options.sharedStrings.add({ richText: model.richText });
+                    }
+                    else if (model.text !== undefined && model.text !== null) {
+                        model.ssId = options.sharedStrings.add(model.text);
+                    }
                 }
                 options.hyperlinks.push({
                     address: model.address,
@@ -85,6 +146,22 @@ class CellXform extends BaseXform {
                     // in case valueType is date
                     model.date1904 = true;
                 }
+                // Convert isDynamicArray flag to cm attribute for XML rendering.
+                // All dynamic array cells share cm=1 pointing to a single XLDAPR metadata record.
+                if (model.isDynamicArray) {
+                    model.cm = 1;
+                }
+                // A formula cell may also carry an attached hyperlink (e.g. when the
+                // model came from another writer or was constructed without going
+                // through the load-side reconcile that promotes type=Formula to
+                // type=Hyperlink). Re-emit the <hyperlink> element so it survives.
+                if (model.hyperlink) {
+                    options.hyperlinks.push({
+                        address: model.address,
+                        target: model.hyperlink,
+                        tooltip: model.tooltip
+                    });
+                }
                 if (model.shareType === "shared") {
                     model.si = options.siFormulae++;
                 }
@@ -180,6 +257,10 @@ class CellXform extends BaseXform {
         if (model.styleId) {
             xmlStream.addAttribute("s", model.styleId);
         }
+        // Dynamic array formulas require the cm attribute linking to xl/metadata.xml
+        if (model.cm) {
+            xmlStream.addAttribute("cm", model.cm);
+        }
         switch (model.type) {
             case Enums.ValueType.Null:
                 break;
@@ -222,10 +303,28 @@ class CellXform extends BaseXform {
                 xmlStream.leafNode("v", null, dateToExcel(model.value, model.date1904));
                 break;
             case Enums.ValueType.Hyperlink:
-                if (model.ssId !== undefined) {
+                // A hyperlink cell may also carry a formula (loaded from XLSX where
+                // a `<hyperlink>` entry shares its address with a formula `<c>`).
+                // Render the formula in that case so the underlying expression
+                // survives the round-trip; the <hyperlink> element is emitted
+                // separately via options.hyperlinks (collected in prepare).
+                if (model.formula || model.sharedFormula) {
+                    this.renderFormula(xmlStream, model);
+                }
+                else if (model.ssId !== undefined) {
                     xmlStream.addAttribute("t", "s");
                     xmlStream.leafNode("v", null, model.ssId);
                 }
+                else if (Array.isArray(model.richText) && model.richText.length > 0) {
+                    // Inline rich-text representation — used when shared strings are
+                    // disabled (some streaming configurations).
+                    xmlStream.addAttribute("t", "inlineStr");
+                    xmlStream.openNode("is");
+                    model.richText.forEach(text => {
+                        this.richTextXform.render(xmlStream, text);
+                    });
+                    xmlStream.closeNode("is");
+                }
                 else {
                     xmlStream.addAttribute("t", "str");
                     xmlStream.leafNode("v", null, model.text);
@@ -257,6 +356,9 @@ class CellXform extends BaseXform {
                 if (node.attributes.s) {
                     this.model.styleId = parseInt(node.attributes.s, 10);
                 }
+                if (node.attributes.cm) {
+                    this.model.cm = parseInt(node.attributes.cm, 10);
+                }
                 return true;
             case "f":
                 this.currentNode = "f";
@@ -386,6 +488,9 @@ class CellXform extends BaseXform {
             case "r":
                 this.model.value = this.model.value || {};
                 this.model.value.richText = this.model.value.richText ?? [];
+                // `this.parser` is guaranteed by parseOpen("r"), which instantiates
+                // a RichTextXform. A missing parser here means malformed XML that
+                // should surface as a parse error rather than silently swallow.
                 this.model.value.richText.push(this.parser.model);
                 this.parser = undefined;
                 this.currentNode = undefined;
@@ -409,11 +514,28 @@ class CellXform extends BaseXform {
         switch (model.type) {
             case Enums.ValueType.String:
                 if (typeof model.value === "number") {
+                    // A numeric value on a String-typed cell is a sharedStrings index
+                    // (originated from t="s" in parseClose).
+                    //
+                    // Two malformed-file cases to consider:
+                    //   1. sharedStrings table missing entirely — degrade gracefully
+                    //      (consistent with the "missing-bits.xlsx" graceful-loading
+                    //      contract); leave value as the raw index so worksheets still
+                    //      load.
+                    //   2. sharedStrings table present but the specific index is out of
+                    //      range — this is the case that previously crashed with
+                    //      `TypeError: cannot access property "richText"`. Fail loudly
+                    //      with a typed ExcelError so callers get file-corruption
+                    //      context.
                     if (options.sharedStrings) {
-                        model.value = options.sharedStrings.getString(model.value);
+                        const ssIndex = model.value;
+                        model.value = options.sharedStrings.getString(ssIndex);
+                        if (model.value === undefined) {
+                            throw new ExcelError(`Invalid shared string index ${ssIndex} in cell ${model.address}: the xlsx file appears to be corrupted`);
+                        }
                     }
                 }
-                if (model.value.richText) {
+                if (model.value && model.value.richText) {
                     model.type = Enums.ValueType.RichText;
                 }
                 break;
@@ -444,6 +566,24 @@ class CellXform extends BaseXform {
                     }
                     delete model.si;
                 }
+                // Convert cm metadata index into isDynamicArray flag.
+                // The cm attribute (1-indexed) links to a cellMetadata record in
+                // xl/metadata.xml. We use the precise dynamicArrayCmIndices set
+                // (built by MetadataXform) to check whether this specific cm value
+                // maps to an XLDAPR metadataType. Falls back to the coarser
+                // hasDynamicArrayMetadata boolean for backwards compatibility.
+                // We strip cm from the model — it will be reassigned during write prepare.
+                if (model.cm) {
+                    if (options.dynamicArrayCmIndices) {
+                        if (options.dynamicArrayCmIndices.has(model.cm)) {
+                            model.isDynamicArray = true;
+                        }
+                    }
+                    else if (options.hasDynamicArrayMetadata) {
+                        model.isDynamicArray = true;
+                    }
+                }
+                delete model.cm;
                 break;
             default:
                 break;
@@ -451,14 +591,32 @@ class CellXform extends BaseXform {
         // look for hyperlink
         const hyperlink = options.hyperlinkMap[model.address];
         if (hyperlink) {
+            // CellHyperlinkValue.text is typed as string; if the shared-string
+            // resolution produced a rich-text payload ({ richText: [...] }) we must
+            // flatten it for `text` AND preserve the runs on `richText` so formatted
+            // display survives round-trip. (See issue #142.)
+            let source;
             if (model.type === Enums.ValueType.Formula) {
-                model.text = model.result;
-                model.result = undefined;
+                // Formula + hyperlink: surface as a Hyperlink cell whose display is
+                // the formula's evaluated result, but keep `model.formula` (and the
+                // original result) on the model so write-time can re-emit both the
+                // formula <c> and the <hyperlink> entry. The cell value layer ignores
+                // unknown model fields, so the public Hyperlink shape stays clean
+                // while round-trip data is preserved internally.
+                source = model.result;
             }
             else {
-                model.text = model.value;
+                source = model.value;
                 model.value = undefined;
             }
+            const display = extractHyperlinkDisplay(source);
+            model.text = display.text;
+            if (display.richText) {
+                model.richText = display.richText;
+            }
+            else {
+                delete model.richText;
+            }
             model.type = Enums.ValueType.Hyperlink;
             model.hyperlink = hyperlink;
         }

package/dist/esm/modules/excel/xlsx/xform/sheet/data-validations-xform.js

@@ -57,7 +57,7 @@ function optimiseDataValidations(model) {
         dataValidation,
         marked: false
     }))
-        .sort((a, b) => a.address.localeCompare(b.address));
+        .sort((a, b) => colCache.compareAddress(a.address, b.address));
     const dvMap = Object.fromEntries(dvList.map(dv => [dv.address, dv]));
     const matchCol = (addr, height, col) => {
         for (let i = 0; i < height; i++) {

package/dist/esm/modules/excel/xlsx/xform/sheet/ignored-errors-xform.js

@@ -0,0 +1,80 @@
+import { BaseXform } from "../base-xform.js";
+/**
+ * Boolean attribute names supported on <ignoredError> elements.
+ * These correspond to the OOXML spec CT_IgnoredError attributes.
+ */
+const BOOL_ATTRS = [
+    "numberStoredAsText",
+    "formula",
+    "formulaRange",
+    "unlockedFormula",
+    "emptyCellReference",
+    "listDataValidation",
+    "calculatedColumn",
+    "evalError",
+    "twoDigitTextYear"
+];
+/**
+ * Xform for the <ignoredErrors> element in a worksheet.
+ *
+ * Renders:
+ * ```xml
+ * <ignoredErrors>
+ *   <ignoredError sqref="A1:B10" numberStoredAsText="1" />
+ * </ignoredErrors>
+ * ```
+ */
+class IgnoredErrorsXform extends BaseXform {
+    get tag() {
+        return "ignoredErrors";
+    }
+    render(xmlStream, model) {
+        if (!model || model.length === 0) {
+            return;
+        }
+        xmlStream.openNode("ignoredErrors");
+        for (const entry of model) {
+            const attrs = { sqref: entry.ref };
+            for (const attr of BOOL_ATTRS) {
+                if (entry[attr]) {
+                    attrs[attr] = 1;
+                }
+            }
+            xmlStream.leafNode("ignoredError", attrs);
+        }
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case "ignoredErrors":
+                this.model = [];
+                return true;
+            case "ignoredError": {
+                const entry = {
+                    ref: node.attributes.sqref ?? ""
+                };
+                for (const attr of BOOL_ATTRS) {
+                    if (node.attributes[attr] === "1" || node.attributes[attr] === "true") {
+                        entry[attr] = true;
+                    }
+                }
+                this.model.push(entry);
+                return true;
+            }
+            default:
+                return true;
+        }
+    }
+    parseText() {
+        // no text content
+    }
+    parseClose(name) {
+        switch (name) {
+            case "ignoredErrors":
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+export { IgnoredErrorsXform };

package/dist/esm/modules/excel/xlsx/xform/sheet/worksheet-xform.js

@@ -14,6 +14,7 @@ import { DrawingXform } from "./drawing-xform.js";
 import { ExtLstXform } from "./ext-lst-xform.js";
 import { HeaderFooterXform } from "./header-footer-xform.js";
 import { isInternalLink, HyperlinkXform } from "./hyperlink-xform.js";
+import { IgnoredErrorsXform } from "./ignored-errors-xform.js";
 import { MergeCellXform } from "./merge-cell-xform.js";
 import { Merges } from "./merges.js";
 import { PageMarginsXform } from "./page-margins-xform.js";
@@ -131,7 +132,8 @@ class WorkSheetXform extends BaseXform {
                 childXform: new TablePartXform()
             }),
             conditionalFormatting: new ConditionalFormattingsXform(),
-            extLst: new ExtLstXform()
+            extLst: new ExtLstXform(),
+            ignoredErrors: new IgnoredErrorsXform()
         };
     }
     prepare(model, options) {
@@ -608,7 +610,9 @@ class WorkSheetXform extends BaseXform {
             xmlStream.leafNode("mc:Fallback");
             xmlStream.closeNode();
         }
-        // Table parts must come after <controls> in worksheet element order.
+        // ignoredErrors must come after controls, before tableParts (OOXML schema order).
+        this.map.ignoredErrors.render(xmlStream, model.ignoredErrors);
+        // tableParts must come after ignoredErrors.
         this.map.tableParts.render(xmlStream, model.tables);
         // extLst should be the last element in the worksheet.
         this.map.extLst.render(xmlStream, model);
@@ -677,7 +681,8 @@ class WorkSheetXform extends BaseXform {
                     tables: this.map.tableParts.model,
                     conditionalFormattings,
                     rowBreaks: this.map.rowBreaks.model ?? [],
-                    colBreaks: this.map.colBreaks.model ?? []
+                    colBreaks: this.map.colBreaks.model ?? [],
+                    ignoredErrors: this.map.ignoredErrors.model ?? []
                 };
                 if (this.map.autoFilter.model) {
                     this.model.autoFilter = this.map.autoFilter.model;
@@ -769,7 +774,7 @@ class WorkSheetXform extends BaseXform {
                             name: drawingName,
                             rels: options.drawingRels?.[drawingName] ?? drawing.rels ?? []
                         };
-                        // Also extract images to model.media for backward compatibility
+                        // Also extract images to model.media for backward compatibility.
                         drawing.anchors.forEach(anchor => {
                             if (anchor.medium) {
                                 // Detect overlay watermarks: drawings that carry alphaModFix

package/dist/esm/modules/excel/xlsx/xform/style/border-xform.js

@@ -167,13 +167,15 @@ class BorderXform extends BaseXform {
             return true;
         }
         if (name === "border") {
-            const model = (this.model = {});
+            const model = {};
+            let hasContent = false;
             const add = (key, edgeModel, extensions) => {
                 if (edgeModel) {
                     if (extensions) {
                         Object.assign(edgeModel, extensions);
                     }
                     model[key] = edgeModel;
+                    hasContent = true;
                 }
             };
             add("left", this.map.left.model);
@@ -181,6 +183,7 @@ class BorderXform extends BaseXform {
             add("top", this.map.top.model);
             add("bottom", this.map.bottom.model);
             add("diagonal", this.map.diagonal.model, { up: this.diagonalUp, down: this.diagonalDown });
+            this.model = hasContent ? model : undefined;
         }
         return false;
     }