@cj-tech-master/excelts 9.2.1 → 9.3.0

package/dist/cjs/modules/excel/xlsx/xform/book/workbook-xform.js

@@ -4,10 +4,12 @@ exports.WorkbookXform = void 0;
 const col_cache_1 = require("../../../utils/col-cache.js");
 const base_xform_1 = require("../base-xform.js");
 const defined_name_xform_1 = require("./defined-name-xform.js");
+const external_reference_xform_1 = require("./external-reference-xform.js");
 const sheet_xform_1 = require("./sheet-xform.js");
 const workbook_calc_properties_xform_1 = require("./workbook-calc-properties-xform.js");
 const workbook_pivot_cache_xform_1 = require("./workbook-pivot-cache-xform.js");
 const workbook_properties_xform_1 = require("./workbook-properties-xform.js");
+const workbook_protection_xform_1 = require("./workbook-protection-xform.js");
 const workbook_view_xform_1 = require("./workbook-view-xform.js");
 const list_xform_1 = require("../list-xform.js");
 const static_xform_1 = require("../static-xform.js");
@@ -18,6 +20,7 @@ class WorkbookXform extends base_xform_1.BaseXform {
         this.map = {
             fileVersion: WorkbookXform.STATIC_XFORMS.fileVersion,
             workbookPr: new workbook_properties_xform_1.WorkbookPropertiesXform(),
+            workbookProtection: new workbook_protection_xform_1.WorkbookProtectionXform(),
             bookViews: new list_xform_1.ListXform({
                 tag: "bookViews",
                 count: false,
@@ -34,6 +37,11 @@ class WorkbookXform extends base_xform_1.BaseXform {
                 tag: "pivotCaches",
                 count: false,
                 childXform: new workbook_pivot_cache_xform_1.WorkbookPivotCacheXform()
+            }),
+            externalReferences: new list_xform_1.ListXform({
+                tag: "externalReferences",
+                count: false,
+                childXform: new external_reference_xform_1.ExternalReferenceXform()
             })
         };
     }
@@ -93,6 +101,7 @@ class WorkbookXform extends base_xform_1.BaseXform {
         xmlStream.openNode("workbook", WorkbookXform.WORKBOOK_ATTRIBUTES);
         this.map.fileVersion.render(xmlStream);
         this.map.workbookPr.render(xmlStream, model.properties);
+        this.map.workbookProtection.render(xmlStream, model.protection);
         this.map.bookViews.render(xmlStream, model.views);
         this.map.sheets.render(xmlStream, model.sheets);
         this.map.definedNames.render(xmlStream, model.definedNames);
@@ -110,6 +119,15 @@ class WorkbookXform extends base_xform_1.BaseXform {
             return true;
         });
         this.map.pivotCaches.render(xmlStream, uniquePivotCaches);
+        // <externalReferences> order matters: one entry per externalLink in
+        // declaration order, each carrying the r:id that resolves (via
+        // workbook.xml.rels) to `xl/externalLinks/externalLink{N}.xml`. The
+        // index inside this list is exactly the `[N]` used in formula strings.
+        const externalLinks = model.externalLinks ?? [];
+        if (externalLinks.length > 0) {
+            const externalReferenceModels = externalLinks.map((link) => ({ rId: link.rId }));
+            this.map.externalReferences.render(xmlStream, externalReferenceModels);
+        }
         xmlStream.closeNode();
     }
     parseOpen(node) {
@@ -145,8 +163,9 @@ class WorkbookXform extends base_xform_1.BaseXform {
                 this.model = {
                     sheets: this.map.sheets.model,
                     properties: this.map.workbookPr.model || {},
+                    protection: this.map.workbookProtection.model,
                     views: this.map.bookViews.model,
-                    calcProperties: {}
+                    calcProperties: this.map.calcPr.model || {}
                 };
                 if (this.map.definedNames.model) {
                     this.model.definedNames = this.map.definedNames.model;
@@ -154,6 +173,13 @@ class WorkbookXform extends base_xform_1.BaseXform {
                 if (this.map.pivotCaches.model && this.map.pivotCaches.model.length > 0) {
                     this.model.pivotCaches = this.map.pivotCaches.model;
                 }
+                // Attach parsed <externalReferences> as a list of { rId } objects.
+                // The reader in xlsx.browser.ts will later join each entry with the
+                // matching workbookRels row (to pick up the externalLink Target) and
+                // the parsed externalLinkN.xml part (to pick up sheetNames / cache).
+                if (this.map.externalReferences.model && this.map.externalReferences.model.length > 0) {
+                    this.model.externalReferences = this.map.externalReferences.model;
+                }
                 return false;
             default:
                 // not quite sure how we get here!
@@ -193,13 +219,20 @@ class WorkbookXform extends base_xform_1.BaseXform {
         const definedNames = [];
         if (model.definedNames) {
             model.definedNames.forEach((definedName) => {
+                // For print area/titles, use rawText to extract ranges since the xform
+                // layer no longer pre-classifies content (two-phase design).
+                const effectiveRanges = definedName.ranges?.length > 0
+                    ? definedName.ranges
+                    : definedName.rawText
+                        ? [definedName.rawText]
+                        : [];
                 if (definedName.name === "_xlnm.Print_Area") {
                     worksheet = worksheets[definedName.localSheetId];
-                    if (worksheet && definedName.ranges?.length > 0) {
+                    if (worksheet && effectiveRanges.length > 0) {
                         if (!worksheet.pageSetup) {
                             worksheet.pageSetup = {};
                         }
-                        const range = col_cache_1.colCache.decodeEx(definedName.ranges[0]);
+                        const range = col_cache_1.colCache.decodeEx(effectiveRanges[0]);
                         worksheet.pageSetup.printArea = worksheet.pageSetup.printArea
                             ? `${worksheet.pageSetup.printArea}&&${range.dimensions}`
                             : range.dimensions;
@@ -207,11 +240,11 @@ class WorkbookXform extends base_xform_1.BaseXform {
                 }
                 else if (definedName.name === "_xlnm.Print_Titles") {
                     worksheet = worksheets[definedName.localSheetId];
-                    if (worksheet && definedName.ranges?.length > 0) {
+                    if (worksheet && effectiveRanges.length > 0) {
                         if (!worksheet.pageSetup) {
                             worksheet.pageSetup = {};
                         }
-                        const rangeString = definedName.ranges.join(",");
+                        const rangeString = effectiveRanges.join(",");
                         const dollarRegex = /\$/g;
                         const rowRangeRegex = /\$\d+:\$\d+/;
                         const rowRangeMatches = rangeString.match(rowRangeRegex);

package/dist/cjs/modules/excel/xlsx/xform/core/content-types-xform.js

@@ -77,6 +77,17 @@ class ContentTypesXform extends base_xform_1.BaseXform {
             PartName: (0, ooxml_paths_1.toContentTypesPartName)(ooxml_paths_1.OOXML_PATHS.xlStyles),
             ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"
         });
+        // Each externalLink part needs its own Override. Omitted entries make
+        // Excel fail to load the external reference (and, in some builds,
+        // trigger a "the workbook is damaged" dialog).
+        if (model.externalLinks && model.externalLinks.length > 0) {
+            for (const link of model.externalLinks) {
+                xmlStream.leafNode("Override", {
+                    PartName: (0, ooxml_paths_1.toContentTypesPartName)((0, ooxml_paths_1.externalLinkPath)(link.index)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml"
+                });
+            }
+        }
         // Add FeaturePropertyBag if checkboxes are used
         if (model.hasCheckboxes) {
             xmlStream.leafNode("Override", {
@@ -84,6 +95,13 @@ class ContentTypesXform extends base_xform_1.BaseXform {
                 ContentType: "application/vnd.ms-excel.featurepropertybag+xml"
             });
         }
+        // Add metadata part for dynamic array formulas
+        if (model.hasDynamicArrayFormulas) {
+            xmlStream.leafNode("Override", {
+                PartName: (0, ooxml_paths_1.toContentTypesPartName)(ooxml_paths_1.OOXML_PATHS.xlMetadata),
+                ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml"
+            });
+        }
         const hasSharedStrings = model.sharedStrings && model.sharedStrings.count;
         if (hasSharedStrings) {
             xmlStream.leafNode("Override", {

package/dist/cjs/modules/excel/xlsx/xform/core/metadata-xform.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataXform = void 0;
+const base_xform_1 = require("../base-xform.js");
+const writer_1 = require("../../../../xml/writer.js");
+// Namespace URIs
+const NS_SPREADSHEETML = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+const NS_DYNAMIC_ARRAY = "http://schemas.microsoft.com/office/spreadsheetml/2017/dynamicarray";
+const XLDAPR_EXT_URI = "{bdbb8cdc-fa1e-496e-a857-3c3f30c029c3}";
+class MetadataXform extends base_xform_1.BaseXform {
+    constructor() {
+        super(...arguments);
+        // Parsing state
+        /** metadataType names in declaration order (1-indexed in OOXML) */
+        this._metadataTypeNames = [];
+        /** Per cellMetadata bk: the rc.t value (metadataType index, 1-indexed) */
+        this._cellMetadataTypeRefs = [];
+        /** Whether we are currently inside <cellMetadata> */
+        this._inCellMetadata = false;
+        /** Current rc.t value being collected inside a <bk> */
+        this._currentRcType = undefined;
+    }
+    get tag() {
+        return "metadata";
+    }
+    /**
+     * Render xl/metadata.xml for the given model.
+     * Only emits content when dynamicArrayCount > 0.
+     */
+    render(xmlStream, model) {
+        if (!model || model.dynamicArrayCount <= 0) {
+            return;
+        }
+        xmlStream.openXml(writer_1.StdDocAttributes);
+        xmlStream.openNode("metadata", {
+            xmlns: NS_SPREADSHEETML,
+            "xmlns:xda": NS_DYNAMIC_ARRAY
+        });
+        // metadataTypes: declare XLDAPR
+        xmlStream.openNode("metadataTypes", { count: "1" });
+        xmlStream.leafNode("metadataType", {
+            name: "XLDAPR",
+            minSupportedVersion: "120000",
+            copy: "1",
+            pasteAll: "1",
+            pasteValues: "1",
+            merge: "1",
+            splitFirst: "1",
+            rowColShift: "1",
+            clearFormats: "1",
+            clearComments: "1",
+            assign: "1",
+            coerce: "1",
+            adjust: "1",
+            cellMeta: "1"
+        });
+        xmlStream.closeNode(); // </metadataTypes>
+        // futureMetadata: one shared block for all DA formulas
+        xmlStream.openNode("futureMetadata", { name: "XLDAPR", count: "1" });
+        xmlStream.openNode("bk");
+        xmlStream.openNode("extLst");
+        xmlStream.openNode("ext", { uri: XLDAPR_EXT_URI });
+        xmlStream.leafNode("xda:dynamicArrayProperties", {
+            fDynamic: "1",
+            fCollapsed: "0"
+        });
+        xmlStream.closeNode(); // </ext>
+        xmlStream.closeNode(); // </extLst>
+        xmlStream.closeNode(); // </bk>
+        xmlStream.closeNode(); // </futureMetadata>
+        // cellMetadata: one record (all DA cells share cm="1" which points here)
+        xmlStream.openNode("cellMetadata", { count: "1" });
+        xmlStream.openNode("bk");
+        // t="1" → metadataType index (1-indexed), v="0" → futureMetadata block index (0-indexed)
+        xmlStream.leafNode("rc", { t: "1", v: "0" });
+        xmlStream.closeNode(); // </bk>
+        xmlStream.closeNode(); // </cellMetadata>
+        xmlStream.closeNode(); // </metadata>
+    }
+    // =========================================================================
+    // Parse: build precise cm → metadataType mapping
+    // =========================================================================
+    reset() {
+        this._metadataTypeNames = [];
+        this._cellMetadataTypeRefs = [];
+        this._inCellMetadata = false;
+        this._currentRcType = undefined;
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case "metadata":
+                this.reset();
+                return true;
+            case "metadataType":
+                // Collect type names in declaration order (1-indexed in OOXML,
+                // but stored 0-indexed here — we adjust when looking up).
+                this._metadataTypeNames.push(node.attributes.name || "");
+                return true;
+            case "cellMetadata":
+                this._inCellMetadata = true;
+                return true;
+            case "bk":
+                if (this._inCellMetadata) {
+                    this._currentRcType = undefined;
+                }
+                return true;
+            case "rc":
+                if (this._inCellMetadata && node.attributes.t !== undefined) {
+                    this._currentRcType = parseInt(node.attributes.t, 10);
+                }
+                return true;
+            // Parse nested elements without action
+            case "metadataTypes":
+            case "futureMetadata":
+            case "extLst":
+            case "ext":
+            case "xda:dynamicArrayProperties":
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose(name) {
+        switch (name) {
+            case "bk":
+                if (this._inCellMetadata) {
+                    // Record the metadataType reference for this cellMetadata entry.
+                    // rc.t is 1-indexed into metadataTypes; store as-is.
+                    this._cellMetadataTypeRefs.push(this._currentRcType ?? 0);
+                    this._currentRcType = undefined;
+                }
+                return true;
+            case "cellMetadata":
+                this._inCellMetadata = false;
+                return true;
+            case "metadata": {
+                // Build the set of cm values (1-indexed) that map to XLDAPR.
+                // cm on <c> is 1-indexed into cellMetadata bk entries.
+                const dynamicArrayCmIndices = new Set();
+                for (let i = 0; i < this._cellMetadataTypeRefs.length; i++) {
+                    const typeIndex = this._cellMetadataTypeRefs[i]; // 1-indexed
+                    // metadataTypeNames is 0-indexed, so subtract 1
+                    const typeName = this._metadataTypeNames[typeIndex - 1];
+                    if (typeName === "XLDAPR") {
+                        // cm is 1-indexed: bk[0] → cm=1, bk[1] → cm=2, etc.
+                        dynamicArrayCmIndices.add(i + 1);
+                    }
+                }
+                this.model = {
+                    hasDynamicArrays: dynamicArrayCmIndices.size > 0,
+                    dynamicArrayCmIndices
+                };
+                return false; // done parsing
+            }
+            default:
+                return true;
+        }
+    }
+}
+exports.MetadataXform = MetadataXform;

package/dist/cjs/modules/excel/xlsx/xform/drawing/absolute-anchor-xform.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbsoluteAnchorXform = void 0;
+const base_xform_1 = require("../base-xform.js");
+const base_cell_anchor_xform_1 = require("./base-cell-anchor-xform.js");
+const ext_xform_1 = require("./ext-xform.js");
+const pic_xform_1 = require("./pic-xform.js");
+const static_xform_1 = require("../static-xform.js");
+/** https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML */
+const EMU_PER_PIXEL_AT_96_DPI = 9525;
+/**
+ * Xform for the <xdr:pos> element (absolute position in EMU).
+ * Converts between EMU (in XML) and pixels (in model).
+ */
+class PosXform extends base_xform_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {};
+        this.model = { x: 0, y: 0 };
+    }
+    get tag() {
+        return "xdr:pos";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode(this.tag, {
+            x: Math.floor(model.x * EMU_PER_PIXEL_AT_96_DPI),
+            y: Math.floor(model.y * EMU_PER_PIXEL_AT_96_DPI)
+        });
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            this.model = {
+                x: parseInt(node.attributes.x ?? "0", 10) / EMU_PER_PIXEL_AT_96_DPI,
+                y: parseInt(node.attributes.y ?? "0", 10) / EMU_PER_PIXEL_AT_96_DPI
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+/**
+ * Xform for <xdr:absoluteAnchor> — images positioned by absolute coordinates
+ * rather than cell references.
+ *
+ * Structure:
+ * ```xml
+ * <xdr:absoluteAnchor>
+ *   <xdr:pos x="0" y="0"/>
+ *   <xdr:ext cx="1000000" cy="1000000"/>
+ *   <xdr:pic>...</xdr:pic>
+ *   <xdr:clientData/>
+ * </xdr:absoluteAnchor>
+ * ```
+ */
+class AbsoluteAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:pos": new PosXform(),
+            "xdr:ext": new ext_xform_1.ExtXform({ tag: "xdr:ext" }),
+            "xdr:pic": new pic_xform_1.PicXform(),
+            "xdr:clientData": new static_xform_1.StaticXform({ tag: "xdr:clientData" })
+        };
+    }
+    get tag() {
+        return "xdr:absoluteAnchor";
+    }
+    prepare(model, options) {
+        if (model.picture) {
+            this.map["xdr:pic"].prepare(model.picture, options);
+        }
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        this.map["xdr:pos"].render(xmlStream, model.range.pos ?? { x: 0, y: 0 });
+        this.map["xdr:ext"].render(xmlStream, model.range.ext);
+        if (model.picture) {
+            this.map["xdr:pic"].render(xmlStream, model.picture);
+        }
+        this.map["xdr:clientData"].render(xmlStream, {});
+        xmlStream.closeNode();
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                this.model.range.pos = this.map["xdr:pos"].model;
+                this.model.range.ext = this.map["xdr:ext"].model;
+                this.model.picture = this.map["xdr:pic"].model;
+                return false;
+            default:
+                return true;
+        }
+    }
+    reconcile(model, options) {
+        model.medium = this.reconcilePicture(model.picture, options);
+    }
+}
+exports.AbsoluteAnchorXform = AbsoluteAnchorXform;

package/dist/cjs/modules/excel/xlsx/xform/drawing/base-cell-anchor-xform.js

@@ -34,6 +34,9 @@ class BaseCellAnchorXform extends base_xform_1.BaseXform {
     reconcilePicture(model, options) {
         if (model && model.rId) {
             const rel = options.rels[model.rId];
+            if (!rel) {
+                return undefined;
+            }
             const match = rel.Target.match(/.*\/media\/(.+[.][a-zA-Z]{3,4})/);
             if (match) {
                 const name = match[1];

package/dist/cjs/modules/excel/xlsx/xform/drawing/drawing-xform.js

@@ -3,11 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DrawingXform = void 0;
 const col_cache_1 = require("../../../utils/col-cache.js");
 const base_xform_1 = require("../base-xform.js");
+const absolute_anchor_xform_1 = require("./absolute-anchor-xform.js");
 const one_cell_anchor_xform_1 = require("./one-cell-anchor-xform.js");
 const two_cell_anchor_xform_1 = require("./two-cell-anchor-xform.js");
 const writer_1 = require("../../../../xml/writer.js");
 function getAnchorType(model) {
     const range = typeof model.range === "string" ? col_cache_1.colCache.decode(model.range) : model.range;
+    if (range.pos !== undefined) {
+        return "xdr:absoluteAnchor";
+    }
     return range.br ? "xdr:twoCellAnchor" : "xdr:oneCellAnchor";
 }
 class DrawingXform extends base_xform_1.BaseXform {
@@ -15,7 +19,8 @@ class DrawingXform extends base_xform_1.BaseXform {
         super();
         this.map = {
             "xdr:twoCellAnchor": new two_cell_anchor_xform_1.TwoCellAnchorXform(),
-            "xdr:oneCellAnchor": new one_cell_anchor_xform_1.OneCellAnchorXform()
+            "xdr:oneCellAnchor": new one_cell_anchor_xform_1.OneCellAnchorXform(),
+            "xdr:absoluteAnchor": new absolute_anchor_xform_1.AbsoluteAnchorXform()
         };
         this.model = { anchors: [] };
     }
@@ -83,7 +88,10 @@ class DrawingXform extends base_xform_1.BaseXform {
     }
     reconcile(model, options) {
         model.anchors.forEach(anchor => {
-            if (anchor.br) {
+            if (anchor.range?.pos !== undefined) {
+                this.map["xdr:absoluteAnchor"].reconcile(anchor, options);
+            }
+            else if (anchor.br) {
                 this.map["xdr:twoCellAnchor"].reconcile(anchor, options);
             }
             else {