@cj-tech-master/excelts 9.4.2 → 9.5.0

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

@@ -14,6 +14,15 @@ function getAnchorType(model) {
 class DrawingXform extends BaseXform {
     constructor() {
         super();
+        // mc:AlternateContent parse state
+        this._inAlternateContent = false;
+        this._acDepth = 0;
+        this._inChoice = false;
+        this._inFallback = false;
+        this._fallbackDepth = 0;
+        this._choiceRequires = undefined;
+        /** Number of anchors before entering mc:AlternateContent — used to tag new anchors */
+        this._anchorCountBeforeAC = 0;
         this.map = {
             "xdr:twoCellAnchor": new TwoCellAnchorXform(),
             "xdr:oneCellAnchor": new OneCellAnchorXform(),
@@ -34,7 +43,27 @@ class DrawingXform extends BaseXform {
     render(xmlStream, model) {
         const renderModel = model || this.model;
         xmlStream.openXml(StdDocAttributes);
-        xmlStream.openNode(this.tag, DrawingXform.DRAWING_ATTRIBUTES);
+        // `<xdr:wsDr>` must declare every namespace prefix any descendant
+        // uses. Inline `xmlns:mc=…` declarations on a deeply nested
+        // `<mc:AlternateContent>` are legal XML and strictly sufficient for
+        // the parser, but Microsoft Excel's **drawing validator** walks the
+        // anchor tree ahead of the parser and rejects the whole drawing
+        // when it encounters an element whose prefix was not pre-declared
+        // on the wsDr root ("Removed Part: /xl/drawings/drawingN.xml
+        // part. (Drawing shape)"). Excel's own output for any drawing that
+        // hosts ChartEx content therefore declares all six prefixes —
+        // `xdr`, `a`, `r`, `c`, `mc`, `cx` — at the root.
+        //
+        // Switch to the extended namespace set whenever any anchor carries
+        // `alternateContent` metadata (form-control shapes, ChartEx
+        // charts, and their `cx1` variants all use the same wrapper). The
+        // bare `xdr` + `a` set is correct for "legacy only" drawings and
+        // round-trips byte-for-byte with Excel's output for those files.
+        const needsMcNamespaces = renderModel.anchors.some(a => !!a?.alternateContent);
+        const rootAttrs = needsMcNamespaces
+            ? DrawingXform.DRAWING_ATTRIBUTES_WITH_MC
+            : DrawingXform.DRAWING_ATTRIBUTES;
+        xmlStream.openNode(this.tag, rootAttrs);
         renderModel.anchors.forEach(item => {
             const anchor = this.map[item.anchorType];
             anchor.render(xmlStream, item);
@@ -42,6 +71,12 @@ class DrawingXform extends BaseXform {
         xmlStream.closeNode();
     }
     parseOpen(node) {
+        // Inside mc:Fallback — skip everything
+        if (this._inFallback) {
+            this._fallbackDepth++;
+            return true;
+        }
+        // Delegate to active parser
         if (this.parser) {
             this.parser.parseOpen(node);
             return true;
@@ -49,11 +84,29 @@ class DrawingXform extends BaseXform {
         switch (node.name) {
             case this.tag:
                 this.reset();
-                this.model = {
-                    anchors: []
-                };
+                this.model = { anchors: [] };
+                break;
+            case "mc:AlternateContent":
+                this._acDepth = (this._acDepth ?? 0) + 1;
+                if (this._acDepth === 1) {
+                    this._inAlternateContent = true;
+                    this._anchorCountBeforeAC = this.model.anchors.length;
+                }
+                break;
+            case "mc:Choice":
+                if (this._inAlternateContent) {
+                    this._inChoice = true;
+                    this._choiceRequires = node.attributes?.Requires;
+                }
+                break;
+            case "mc:Fallback":
+                if (this._inAlternateContent) {
+                    this._inFallback = true;
+                    this._fallbackDepth = 1;
+                }
                 break;
             default:
+                // Normal anchor dispatch (works both inside mc:Choice and at top level)
                 this.parser = this.map[node.name];
                 if (this.parser) {
                     this.parser.parseOpen(node);
@@ -63,11 +116,22 @@ class DrawingXform extends BaseXform {
         return true;
     }
     parseText(text) {
+        if (this._inFallback) {
+            return;
+        }
         if (this.parser) {
             this.parser.parseText(text);
         }
     }
     parseClose(name) {
+        // Inside mc:Fallback — skip until closed
+        if (this._inFallback) {
+            this._fallbackDepth--;
+            if (this._fallbackDepth === 0) {
+                this._inFallback = false;
+            }
+            return true;
+        }
         if (this.parser) {
             if (!this.parser.parseClose(name)) {
                 this.model.anchors.push(this.parser.model);
@@ -78,8 +142,26 @@ class DrawingXform extends BaseXform {
         switch (name) {
             case this.tag:
                 return false;
+            case "mc:AlternateContent":
+                this._acDepth = (this._acDepth ?? 0) - 1;
+                if (this._acDepth <= 0) {
+                    // Tag any anchors added during this mc:AlternateContent with alternateContent info
+                    if (this._inAlternateContent && this._choiceRequires) {
+                        const anchors = this.model.anchors;
+                        for (let i = this._anchorCountBeforeAC; i < anchors.length; i++) {
+                            anchors[i].alternateContent = { requires: this._choiceRequires };
+                        }
+                    }
+                    this._inAlternateContent = false;
+                    this._inChoice = false;
+                    this._choiceRequires = undefined;
+                    this._acDepth = 0;
+                }
+                return true;
+            case "mc:Choice":
+                this._inChoice = false;
+                return true;
             default:
-                // could be some unrecognised tags
                 return true;
         }
     }
@@ -101,4 +183,26 @@ DrawingXform.DRAWING_ATTRIBUTES = {
     "xmlns:xdr": "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing",
     "xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main"
 };
+/**
+ * Extended namespace set used when the drawing contains anchors
+ * wrapped in `<mc:AlternateContent>` — the ChartEx case. Excel's
+ * strict loader requires the `mc`, `r`, `c`, and `cx` prefixes at
+ * the root of `<xdr:wsDr>` before it will parse `<mc:Choice>` /
+ * `<cx:chart>` descendants. Declaring them only inside the inner
+ * `<mc:AlternateContent>` element (as earlier versions did) made
+ * Excel reject the drawing and report "Removed Part:
+ * /xl/drawings/drawingN.xml (Drawing shape)".
+ *
+ * Mirrors what Excel itself emits when it writes a drawing that
+ * hosts a ChartEx chart — see `__tests__/data/workbook-roundtrip-
+ * chartex.xlsx` (fixtures authored by Excel 2016+).
+ */
+DrawingXform.DRAWING_ATTRIBUTES_WITH_MC = {
+    "xmlns:xdr": "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing",
+    "xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+    "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "xmlns:c": "http://schemas.openxmlformats.org/drawingml/2006/chart",
+    "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+    "xmlns:cx": "http://schemas.microsoft.com/office/drawing/2014/chartex"
+};
 export { DrawingXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/graphic-frame-xform.d.ts

@@ -0,0 +1,54 @@
+/**
+ * GraphicFrameXform — handles `xdr:graphicFrame` elements in drawing XML.
+ *
+ * A graphicFrame is the container for embedded objects such as charts.
+ * The OOXML structure:
+ *
+ *   <xdr:graphicFrame macro="">
+ *     <xdr:nvGraphicFramePr>
+ *       <xdr:cNvPr id="2" name="Chart 1"/>
+ *       <xdr:cNvGraphicFramePr/>
+ *     </xdr:nvGraphicFramePr>
+ *     <xdr:xfrm>
+ *       <a:off x="0" y="0"/>
+ *       <a:ext cx="0" cy="0"/>
+ *     </xdr:xfrm>
+ *     <a:graphic>
+ *       <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart">
+ *         <c:chart xmlns:c="..." xmlns:r="..." r:id="rId1"/>
+ *       </a:graphicData>
+ *     </a:graphic>
+ *   </xdr:graphicFrame>
+ */
+import { BaseXform } from "../base-xform.js";
+export interface GraphicFrameModel {
+    /** Drawing object index (1-based unique id within the drawing part) */
+    index?: number;
+    /** Display name (e.g. "Chart 1") */
+    name?: string;
+    /** Relationship ID referencing the chart part */
+    rId?: string;
+    /** The graphic data URI — defaults to chart URI */
+    graphicDataUri?: string;
+    /** Raw XML for a:extLst inside xdr:cNvPr (round-trip preservation) */
+    cNvPrExtLst?: string;
+    /** True when the graphic frame references a cx:chart (Office 2016+ extended chart) */
+    isChartEx?: boolean;
+}
+declare class GraphicFrameXform extends BaseXform {
+    model: GraphicFrameModel;
+    parser: any;
+    private _inNvPr;
+    private _inGraphicData;
+    /** Raw XML capture for a:extLst inside xdr:cNvPr */
+    private _extLstCapture;
+    get tag(): string;
+    prepare(model: GraphicFrameModel, options: {
+        index: number;
+    }): void;
+    render(xmlStream: any, model: GraphicFrameModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { GraphicFrameXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/graphic-frame-xform.js

@@ -0,0 +1,225 @@
+/**
+ * GraphicFrameXform — handles `xdr:graphicFrame` elements in drawing XML.
+ *
+ * A graphicFrame is the container for embedded objects such as charts.
+ * The OOXML structure:
+ *
+ *   <xdr:graphicFrame macro="">
+ *     <xdr:nvGraphicFramePr>
+ *       <xdr:cNvPr id="2" name="Chart 1"/>
+ *       <xdr:cNvGraphicFramePr/>
+ *     </xdr:nvGraphicFramePr>
+ *     <xdr:xfrm>
+ *       <a:off x="0" y="0"/>
+ *       <a:ext cx="0" cy="0"/>
+ *     </xdr:xfrm>
+ *     <a:graphic>
+ *       <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart">
+ *         <c:chart xmlns:c="..." xmlns:r="..." r:id="rId1"/>
+ *       </a:graphicData>
+ *     </a:graphic>
+ *   </xdr:graphicFrame>
+ */
+import { BaseXform } from "../base-xform.js";
+import { uuidV4 } from "../../../../../utils/uuid.js";
+const CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+const CHART_EX_URI = "http://schemas.microsoft.com/office/drawing/2014/chartex";
+// URI identifying the Office `creationId` extension registered on
+// `xdr:cNvPr`. This GUID is the Microsoft-assigned registry value
+// for the extension — every Office-authored drawing carries the
+// same uri on this element.
+const CREATION_ID_EXT_URI = "{FF2B5EF4-FFF2-40B4-BE49-F238E27FC236}";
+class GraphicFrameXform extends BaseXform {
+    constructor() {
+        super(...arguments);
+        // SAX parse state
+        this._inNvPr = false;
+        this._inGraphicData = false;
+        /** Raw XML capture for a:extLst inside xdr:cNvPr */
+        this._extLstCapture = null;
+    }
+    get tag() {
+        return "xdr:graphicFrame";
+    }
+    prepare(model, options) {
+        if (model.index === undefined) {
+            model.index = options.index + 1;
+        }
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag, { macro: "" });
+        // Non-visual properties
+        xmlStream.openNode("xdr:nvGraphicFramePr");
+        // Microsoft Excel starts `xdr:cNvPr/@id` at 2 (id 1 is
+        // reserved for the anchor's own non-visual drawing id slot
+        // internal to Office's drawing engine). Mirror the convention
+        // here so freshly-authored drawings round-trip byte-for-byte
+        // against Excel's output. Loaded files retain whatever id they
+        // carried at parse time via `model.index`.
+        const cNvPrId = model.index ?? 2;
+        const cNvPrName = model.name ?? `Chart ${cNvPrId}`;
+        if (model.cNvPrExtLst) {
+            xmlStream.openNode("xdr:cNvPr", {
+                id: cNvPrId,
+                name: cNvPrName
+            });
+            xmlStream.writeRaw(model.cNvPrExtLst);
+            xmlStream.closeNode(); // xdr:cNvPr
+        }
+        else if (model.isChartEx) {
+            // ChartEx drawings — auto-generate Microsoft's standard
+            // `<a:extLst>` with an `<a16:creationId>` extension so
+            // Excel 2019+ can track the drawing across sessions.
+            // Without this extension, strict Excel builds have been
+            // observed to reject the drawing part on load with
+            // "Removed Part: /xl/drawings/drawingN.xml (Drawing shape)"
+            // even when the chartEx reference inside is otherwise
+            // valid. A random UUID suffices — the id only has to be
+            // stable within a given saved file; it isn't a content
+            // address.
+            xmlStream.openNode("xdr:cNvPr", {
+                id: cNvPrId,
+                name: cNvPrName
+            });
+            xmlStream.openNode("a:extLst");
+            xmlStream.openNode("a:ext", { uri: CREATION_ID_EXT_URI });
+            xmlStream.leafNode("a16:creationId", {
+                "xmlns:a16": "http://schemas.microsoft.com/office/drawing/2014/main",
+                id: `{${uuidV4().toUpperCase()}}`
+            });
+            xmlStream.closeNode(); // a:ext
+            xmlStream.closeNode(); // a:extLst
+            xmlStream.closeNode(); // xdr:cNvPr
+        }
+        else {
+            xmlStream.leafNode("xdr:cNvPr", {
+                id: cNvPrId,
+                name: cNvPrName
+            });
+        }
+        xmlStream.leafNode("xdr:cNvGraphicFramePr");
+        xmlStream.closeNode(); // xdr:nvGraphicFramePr
+        // Transform (position/size handled by anchor, so use zeros)
+        xmlStream.openNode("xdr:xfrm");
+        xmlStream.leafNode("a:off", { x: 0, y: 0 });
+        xmlStream.leafNode("a:ext", { cx: 0, cy: 0 });
+        xmlStream.closeNode(); // xdr:xfrm
+        // Graphic
+        xmlStream.openNode("a:graphic");
+        if (model.isChartEx) {
+            xmlStream.openNode("a:graphicData", { uri: CHART_EX_URI });
+            xmlStream.leafNode("cx:chart", {
+                "xmlns:cx": CHART_EX_URI,
+                "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+                "r:id": model.rId
+            });
+        }
+        else {
+            xmlStream.openNode("a:graphicData", {
+                uri: model.graphicDataUri ?? CHART_URI
+            });
+            xmlStream.leafNode("c:chart", {
+                "xmlns:c": "http://schemas.openxmlformats.org/drawingml/2006/chart",
+                "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+                "r:id": model.rId
+            });
+        }
+        xmlStream.closeNode(); // a:graphicData
+        xmlStream.closeNode(); // a:graphic
+        xmlStream.closeNode(); // xdr:graphicFrame
+    }
+    parseOpen(node) {
+        // Raw XML capture mode for extLst
+        if (this._extLstCapture) {
+            const attrs = Object.entries(node.attributes || {})
+                .map(([k, v]) => ` ${k}="${v}"`)
+                .join("");
+            if (node.isSelfClosing) {
+                this._extLstCapture.parts.push(`<${node.name}${attrs}/>`);
+                this._extLstCapture.skipNextClose = true;
+            }
+            else {
+                this._extLstCapture.parts.push(`<${node.name}${attrs}>`);
+                this._extLstCapture.depth++;
+            }
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {};
+                this._extLstCapture = null;
+                break;
+            case "xdr:cNvPr":
+                this._inNvPr = true;
+                this.model.index = parseInt(node.attributes.id, 10) || undefined;
+                this.model.name = node.attributes.name;
+                break;
+            case "a:extLst":
+                if (this._inNvPr) {
+                    // Start capturing raw XML
+                    const attrs = Object.entries(node.attributes || {})
+                        .map(([k, v]) => ` ${k}="${v}"`)
+                        .join("");
+                    this._extLstCapture = {
+                        depth: 1,
+                        parts: [`<a:extLst${attrs}>`],
+                        skipNextClose: false
+                    };
+                    return true;
+                }
+                break;
+            case "a:graphicData":
+                this._inGraphicData = true;
+                this.model.graphicDataUri = node.attributes.uri;
+                break;
+            case "c:chart":
+                if (this._inGraphicData) {
+                    this.model.rId = node.attributes["r:id"];
+                }
+                break;
+            case "cx:chart":
+                if (this._inGraphicData) {
+                    this.model.rId = node.attributes["r:id"];
+                    this.model.isChartEx = true;
+                }
+                break;
+            default:
+                break;
+        }
+        return true;
+    }
+    parseText(text) {
+        if (this._extLstCapture && text) {
+            this._extLstCapture.parts.push(text);
+        }
+    }
+    parseClose(name) {
+        if (this._extLstCapture) {
+            if (this._extLstCapture.skipNextClose) {
+                this._extLstCapture.skipNextClose = false;
+                return true;
+            }
+            this._extLstCapture.parts.push(`</${name}>`);
+            this._extLstCapture.depth--;
+            if (this._extLstCapture.depth === 0) {
+                this.model.cNvPrExtLst = this._extLstCapture.parts.join("");
+                this._extLstCapture = null;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                return false;
+            case "xdr:cNvPr":
+                this._inNvPr = false;
+                return true;
+            case "a:graphicData":
+                this._inGraphicData = false;
+                return true;
+            default:
+                return true;
+        }
+    }
+}
+export { GraphicFrameXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/one-cell-anchor-xform.d.ts

@@ -5,7 +5,9 @@ interface OneCellModel {
         tl: any;
         ext: any;
     };
-    picture: any;
+    picture?: any;
+    /** Graphic frame model (for charts and other embedded objects) */
+    graphicFrame?: any;
 }
 declare class OneCellAnchorXform extends BaseCellAnchorXform {
     constructor();

package/dist/browser/modules/excel/xlsx/xform/drawing/one-cell-anchor-xform.js

@@ -1,6 +1,7 @@
 import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
 import { CellPositionXform } from "./cell-position-xform.js";
 import { ExtXform } from "./ext-xform.js";
+import { GraphicFrameXform } from "./graphic-frame-xform.js";
 import { PicXform } from "./pic-xform.js";
 import { StaticXform } from "../static-xform.js";
 class OneCellAnchorXform extends BaseCellAnchorXform {
@@ -10,6 +11,7 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
             "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
             "xdr:ext": new ExtXform({ tag: "xdr:ext" }),
             "xdr:pic": new PicXform(),
+            "xdr:graphicFrame": new GraphicFrameXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -17,13 +19,23 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
         return "xdr:oneCellAnchor";
     }
     prepare(model, options) {
-        this.map["xdr:pic"].prepare(model.picture, options);
+        if (model.picture) {
+            this.map["xdr:pic"].prepare(model.picture, options);
+        }
+        else if (model.graphicFrame) {
+            this.map["xdr:graphicFrame"].prepare(model.graphicFrame, options);
+        }
     }
     render(xmlStream, model) {
         xmlStream.openNode(this.tag, { editAs: model.range.editAs ?? "oneCell" });
         this.map["xdr:from"].render(xmlStream, model.range.tl);
         this.map["xdr:ext"].render(xmlStream, model.range.ext);
-        this.map["xdr:pic"].render(xmlStream, model.picture);
+        if (model.picture) {
+            this.map["xdr:pic"].render(xmlStream, model.picture);
+        }
+        else if (model.graphicFrame) {
+            this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
+        }
         this.map["xdr:clientData"].render(xmlStream, {});
         xmlStream.closeNode();
     }
@@ -39,6 +51,7 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
                 this.model.range.tl = this.map["xdr:from"].model;
                 this.model.range.ext = this.map["xdr:ext"].model;
                 this.model.picture = this.map["xdr:pic"].model;
+                this.model.graphicFrame = this.map["xdr:graphicFrame"].model;
                 return false;
             default:
                 // could be some unrecognised tags
@@ -46,7 +59,9 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
         }
     }
     reconcile(model, options) {
-        model.medium = this.reconcilePicture(model.picture, options);
+        if (model.picture) {
+            model.medium = this.reconcilePicture(model.picture, options);
+        }
     }
 }
 export { OneCellAnchorXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/two-cell-anchor-xform.d.ts

@@ -7,18 +7,64 @@ interface TwoCellModel {
     };
     picture?: any;
     shape?: any;
+    /** Graphic frame model (for charts and other embedded objects) */
+    graphicFrame?: any;
     /** Wrap the anchor in mc:AlternateContent for modern drawing clients */
     alternateContent?: {
         requires: string;
     };
 }
 declare class TwoCellAnchorXform extends BaseCellAnchorXform {
+    private _acDepth;
+    private _inFallback;
+    private _fallbackDepth;
+    private _choiceRequires;
     constructor();
     get tag(): string;
     prepare(model: TwoCellModel, options: {
         index: number;
     }): void;
     render(xmlStream: any, model: TwoCellModel): void;
+    /**
+     * Emit the ChartEx `<mc:AlternateContent>` block that occupies the
+     * shape slot inside a `<xdr:twoCellAnchor>` — between `<xdr:to>`
+     * and `<xdr:clientData>`.
+     *
+     * Structure mirrors Microsoft Excel's own output:
+     *
+     *   <mc:AlternateContent>
+     *     <mc:Choice Requires="cx1" xmlns:cx1="…/2015/9/8/chartex">
+     *       <xdr:graphicFrame>…<cx:chart/>…</xdr:graphicFrame>
+     *     </mc:Choice>
+     *     <mc:Fallback>
+     *       <xdr:sp>…placeholder shape…</xdr:sp>
+     *     </mc:Fallback>
+     *   </mc:AlternateContent>
+     *
+     * Both the Choice graphicFrame and the Fallback shape inherit
+     * sizing from the outer `<xdr:from>`/`<xdr:to>` cell range — they
+     * do NOT each re-declare the anchor; there is only one anchor.
+     */
+    private renderChartExAlternateContent;
+    /**
+     * Emit the placeholder `<xdr:sp>` that lives inside the
+     * `<mc:Fallback>` of a ChartEx anchor. Legacy Excel (2010/2013)
+     * and non-Microsoft loaders that don't understand the `cx1`
+     * namespace render this in place of the `cx:chart`.
+     *
+     * Matches Microsoft Excel's convention: cNvPr id=0 / empty name
+     * (a deliberate placeholder, not a real drawing object), a white
+     * rectangle sized to the anchor's cell range, and the localizable
+     * "This chart isn't available" message. The shape's own xfrm
+     * carries concrete EMU values rather than zeros because the
+     * Fallback expansion is meant to be rendered standalone — a
+     * zero-size shape would collapse and Excel 2016+ flags that as
+     * "drawing shape" validation failure even though the outer
+     * twoCellAnchor provides sizing.
+     */
+    private renderChartExFallbackShape;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
     parseClose(name: string): boolean;
     reconcile(model: any, options: any): void;
 }