@cj-tech-master/excelts 4.2.1 → 4.2.2-canary.20260115044841.88820eb

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

@@ -3,31 +3,50 @@ import { BaseXform } from "../base-xform.js";
 import { DateXform } from "../simple/date-xform.js";
 import { StringXform } from "../simple/string-xform.js";
 import { IntegerXform } from "../simple/integer-xform.js";
+// Rendering uses namespace prefixes, parsing uses unqualified names (SAX strips prefixes)
+const PROPS = {
+    creator: "dc:creator",
+    title: "dc:title",
+    subject: "dc:subject",
+    description: "dc:description",
+    identifier: "dc:identifier",
+    language: "dc:language",
+    keywords: "cp:keywords",
+    category: "cp:category",
+    lastModifiedBy: "cp:lastModifiedBy",
+    lastPrinted: "cp:lastPrinted",
+    revision: "cp:revision",
+    version: "cp:version",
+    contentStatus: "cp:contentStatus",
+    contentType: "cp:contentType",
+    created: "dcterms:created",
+    modified: "dcterms:modified"
+};
 class CoreXform extends BaseXform {
     constructor() {
         super();
         this.map = {
-            "dc:creator": new StringXform({ tag: "dc:creator" }),
-            "dc:title": new StringXform({ tag: "dc:title" }),
-            "dc:subject": new StringXform({ tag: "dc:subject" }),
-            "dc:description": new StringXform({ tag: "dc:description" }),
-            "dc:identifier": new StringXform({ tag: "dc:identifier" }),
-            "dc:language": new StringXform({ tag: "dc:language" }),
-            "cp:keywords": new StringXform({ tag: "cp:keywords" }),
-            "cp:category": new StringXform({ tag: "cp:category" }),
-            "cp:lastModifiedBy": new StringXform({ tag: "cp:lastModifiedBy" }),
-            "cp:lastPrinted": new DateXform({ tag: "cp:lastPrinted", format: CoreXform.DateFormat }),
-            "cp:revision": new IntegerXform({ tag: "cp:revision" }),
-            "cp:version": new StringXform({ tag: "cp:version" }),
-            "cp:contentStatus": new StringXform({ tag: "cp:contentStatus" }),
-            "cp:contentType": new StringXform({ tag: "cp:contentType" }),
-            "dcterms:created": new DateXform({
-                tag: "dcterms:created",
+            creator: new StringXform({ tag: PROPS.creator }),
+            title: new StringXform({ tag: PROPS.title }),
+            subject: new StringXform({ tag: PROPS.subject }),
+            description: new StringXform({ tag: PROPS.description }),
+            identifier: new StringXform({ tag: PROPS.identifier }),
+            language: new StringXform({ tag: PROPS.language }),
+            keywords: new StringXform({ tag: PROPS.keywords }),
+            category: new StringXform({ tag: PROPS.category }),
+            lastModifiedBy: new StringXform({ tag: PROPS.lastModifiedBy }),
+            lastPrinted: new DateXform({ tag: PROPS.lastPrinted, format: CoreXform.DateFormat }),
+            revision: new IntegerXform({ tag: PROPS.revision }),
+            version: new StringXform({ tag: PROPS.version }),
+            contentStatus: new StringXform({ tag: PROPS.contentStatus }),
+            contentType: new StringXform({ tag: PROPS.contentType }),
+            created: new DateXform({
+                tag: PROPS.created,
                 attrs: CoreXform.DateAttrs,
                 format: CoreXform.DateFormat
             }),
-            "dcterms:modified": new DateXform({
-                tag: "dcterms:modified",
+            modified: new DateXform({
+                tag: PROPS.modified,
                 attrs: CoreXform.DateAttrs,
                 format: CoreXform.DateFormat
             })
@@ -36,22 +55,9 @@ class CoreXform extends BaseXform {
     render(xmlStream, model) {
         xmlStream.openXml(XmlStream.StdDocAttributes);
         xmlStream.openNode("cp:coreProperties", CoreXform.CORE_PROPERTY_ATTRIBUTES);
-        this.map["dc:creator"].render(xmlStream, model.creator);
-        this.map["dc:title"].render(xmlStream, model.title);
-        this.map["dc:subject"].render(xmlStream, model.subject);
-        this.map["dc:description"].render(xmlStream, model.description);
-        this.map["dc:identifier"].render(xmlStream, model.identifier);
-        this.map["dc:language"].render(xmlStream, model.language);
-        this.map["cp:keywords"].render(xmlStream, model.keywords);
-        this.map["cp:category"].render(xmlStream, model.category);
-        this.map["cp:lastModifiedBy"].render(xmlStream, model.lastModifiedBy);
-        this.map["cp:lastPrinted"].render(xmlStream, model.lastPrinted);
-        this.map["cp:revision"].render(xmlStream, model.revision);
-        this.map["cp:version"].render(xmlStream, model.version);
-        this.map["cp:contentStatus"].render(xmlStream, model.contentStatus);
-        this.map["cp:contentType"].render(xmlStream, model.contentType);
-        this.map["dcterms:created"].render(xmlStream, model.created);
-        this.map["dcterms:modified"].render(xmlStream, model.modified);
+        for (const key of Object.keys(PROPS)) {
+            this.map[key].render(xmlStream, model[key]);
+        }
         xmlStream.closeNode();
     }
     parseOpen(node) {
@@ -59,18 +65,13 @@ class CoreXform extends BaseXform {
             this.parser.parseOpen(node);
             return true;
         }
-        switch (node.name) {
-            case "cp:coreProperties":
-            case "coreProperties":
-                return true;
-            default:
-                this.parser = this.map[node.name];
-                if (this.parser) {
-                    this.parser.parseOpen(node);
-                    return true;
-                }
-                throw new Error(`Unexpected xml node in parseOpen: ${JSON.stringify(node)}`);
+        if (node.name !== "coreProperties") {
+            this.parser = this.map[node.name];
+            if (this.parser) {
+                this.parser.parseOpen(node);
+            }
         }
+        return true;
     }
     parseText(text) {
         if (this.parser) {
@@ -84,30 +85,17 @@ class CoreXform extends BaseXform {
             }
             return true;
         }
-        switch (name) {
-            case "cp:coreProperties":
-            case "coreProperties":
-                this.model = {
-                    creator: this.map["dc:creator"].model,
-                    title: this.map["dc:title"].model,
-                    subject: this.map["dc:subject"].model,
-                    description: this.map["dc:description"].model,
-                    identifier: this.map["dc:identifier"].model,
-                    language: this.map["dc:language"].model,
-                    keywords: this.map["cp:keywords"].model,
-                    category: this.map["cp:category"].model,
-                    lastModifiedBy: this.map["cp:lastModifiedBy"].model,
-                    lastPrinted: this.map["cp:lastPrinted"].model,
-                    revision: this.map["cp:revision"].model,
-                    contentStatus: this.map["cp:contentStatus"].model,
-                    contentType: this.map["cp:contentType"].model,
-                    created: this.map["dcterms:created"].model,
-                    modified: this.map["dcterms:modified"].model
-                };
-                return false;
-            default:
-                throw new Error(`Unexpected xml node in parseClose: ${name}`);
+        if (name === "coreProperties") {
+            this.model = {};
+            for (const key of Object.keys(PROPS)) {
+                const val = this.map[key].model;
+                if (val !== undefined && val !== "") {
+                    this.model[key] = val;
+                }
+            }
+            return false;
         }
+        return true;
     }
 }
 CoreXform.DateFormat = function (dt) {

package/dist/browser/modules/excel/xlsx/xform/drawing/ctrl-prop-xform.d.ts

@@ -8,6 +8,7 @@ import type { FormCheckboxModel } from "@excel/form-control";
  */
 declare class CtrlPropXform extends BaseXform {
     model: FormCheckboxModel;
+    private _checkedToXmlValue;
     get tag(): string;
     render(xmlStream: any, model?: FormCheckboxModel): void;
     /**

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

@@ -7,6 +7,17 @@ import { BaseXform } from "../base-xform.js";
  * that stores its properties like objectType, checked state, and linked cell.
  */
 class CtrlPropXform extends BaseXform {
+    _checkedToXmlValue(checked) {
+        switch (checked) {
+            case "Checked":
+                return "1";
+            case "Mixed":
+                return "2";
+            case "Unchecked":
+            default:
+                return "0";
+        }
+    }
     get tag() {
         return "formControlPr";
     }
@@ -15,7 +26,8 @@ class CtrlPropXform extends BaseXform {
         const attrs = {
             xmlns: "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main",
             objectType: "CheckBox",
-            checked: renderModel.checked,
+            // Excel tends to serialize this as numeric state (0/1/2), matching VML x:Checked.
+            checked: this._checkedToXmlValue(renderModel.checked),
             lockText: "1"
         };
         // Add linked cell reference

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

@@ -0,0 +1,18 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+export interface ShapeModel {
+    /** Drawing object id (must be unique within drawing part) */
+    cNvPrId: number;
+    /** Display name (e.g. "Check Box 1") */
+    name: string;
+    /** VML spid compat value (e.g. "_x0000_s1025") */
+    spid: string;
+    /** Text shown in the shape text box */
+    text: string;
+    /** Whether the shape should be hidden */
+    hidden?: boolean;
+}
+declare class SpXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: ShapeModel): void;
+}
+export { SpXform };

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

@@ -0,0 +1,112 @@
+import { BaseXform } from "../base-xform.js";
+class SpXform extends BaseXform {
+    get tag() {
+        return "xdr:sp";
+    }
+    render(xmlStream, model) {
+        if (!model) {
+            return;
+        }
+        xmlStream.openNode(this.tag, { macro: "", textlink: "" });
+        // Non-visual properties
+        xmlStream.openNode("xdr:nvSpPr");
+        xmlStream.openNode("xdr:cNvPr", {
+            id: model.cNvPrId,
+            name: model.name,
+            hidden: model.hidden ? "1" : undefined
+        });
+        xmlStream.openNode("a:extLst");
+        xmlStream.openNode("a:ext", {
+            uri: "{63B3BB69-23CF-44E3-9099-C40C66FF867C}"
+        });
+        xmlStream.leafNode("a14:compatExt", {
+            spid: model.spid,
+            "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
+        }, undefined);
+        xmlStream.closeNode(); // a:ext
+        xmlStream.closeNode(); // a:extLst
+        xmlStream.closeNode(); // xdr:cNvPr
+        xmlStream.leafNode("xdr:cNvSpPr");
+        xmlStream.closeNode(); // xdr:nvSpPr
+        // Shape properties
+        xmlStream.openNode("xdr:spPr", { bwMode: "auto" });
+        xmlStream.openNode("a:xfrm");
+        xmlStream.leafNode("a:off", { x: 0, y: 0 });
+        xmlStream.leafNode("a:ext", { cx: 0, cy: 0 });
+        xmlStream.closeNode(); // a:xfrm
+        xmlStream.openNode("a:prstGeom", { prst: "rect" });
+        xmlStream.leafNode("a:avLst");
+        xmlStream.closeNode(); // a:prstGeom
+        xmlStream.leafNode("a:noFill");
+        xmlStream.openNode("a:ln");
+        xmlStream.leafNode("a:noFill");
+        xmlStream.closeNode(); // a:ln
+        xmlStream.openNode("a:extLst");
+        xmlStream.openNode("a:ext", { uri: "{909E8E84-426E-40DD-AFC4-6F175D3DCCD1}" });
+        xmlStream.openNode("a14:hiddenFill", {
+            "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
+        });
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:srgbClr", { val: "F0F0F0" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.closeNode(); // a14:hiddenFill
+        xmlStream.closeNode(); // a:ext
+        xmlStream.openNode("a:ext", { uri: "{91240B29-F687-4F45-9708-019B960494DF}" });
+        xmlStream.openNode("a14:hiddenLine", {
+            w: 9525,
+            "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
+        });
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:srgbClr", { val: "000000" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.leafNode("a:miter", { lim: 800000 });
+        xmlStream.leafNode("a:headEnd");
+        xmlStream.leafNode("a:tailEnd");
+        xmlStream.closeNode(); // a14:hiddenLine
+        xmlStream.closeNode(); // a:ext
+        xmlStream.closeNode(); // a:extLst
+        xmlStream.closeNode(); // xdr:spPr
+        // Text body (label)
+        xmlStream.openNode("xdr:txBody");
+        xmlStream.leafNode("a:bodyPr", {
+            vertOverflow: "clip",
+            wrap: "square",
+            lIns: 18288,
+            tIns: 18288,
+            rIns: 0,
+            bIns: 18288,
+            anchor: "ctr",
+            upright: 1
+        });
+        xmlStream.leafNode("a:lstStyle");
+        xmlStream.openNode("a:p");
+        xmlStream.openNode("a:pPr", { algn: "l", rtl: 0 });
+        xmlStream.leafNode("a:defRPr", { sz: 1000 });
+        xmlStream.closeNode(); // a:pPr
+        xmlStream.openNode("a:r");
+        xmlStream.openNode("a:rPr", {
+            lang: "en-US",
+            sz: 800,
+            b: 0,
+            i: 0,
+            u: "none",
+            strike: "noStrike",
+            baseline: 0
+        });
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:srgbClr", { val: "000000" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.leafNode("a:latin", { typeface: "Tahoma", pitchFamily: 2, charset: 0 });
+        xmlStream.leafNode("a:ea", { typeface: "Tahoma", pitchFamily: 2, charset: 0 });
+        xmlStream.leafNode("a:cs", { typeface: "Tahoma", pitchFamily: 2, charset: 0 });
+        xmlStream.closeNode(); // a:rPr
+        xmlStream.openNode("a:t");
+        xmlStream.writeText(model.text ?? "");
+        xmlStream.closeNode(); // a:t
+        xmlStream.closeNode(); // a:r
+        xmlStream.closeNode(); // a:p
+        xmlStream.closeNode(); // xdr:txBody
+        xmlStream.closeNode(); // xdr:sp
+    }
+}
+export { SpXform };

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

@@ -5,7 +5,12 @@ interface TwoCellModel {
         tl: any;
         br: any;
     };
-    picture: any;
+    picture?: any;
+    shape?: any;
+    /** Wrap the anchor in mc:AlternateContent for modern drawing clients */
+    alternateContent?: {
+        requires: string;
+    };
 }
 declare class TwoCellAnchorXform extends BaseCellAnchorXform {
     constructor();

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

@@ -2,6 +2,7 @@ import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
 import { StaticXform } from "../static-xform.js";
 import { CellPositionXform } from "./cell-position-xform.js";
 import { PicXform } from "./pic-xform.js";
+import { SpXform } from "./sp-xform.js";
 class TwoCellAnchorXform extends BaseCellAnchorXform {
     constructor() {
         super();
@@ -9,6 +10,7 @@ class TwoCellAnchorXform extends BaseCellAnchorXform {
             "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
             "xdr:to": new CellPositionXform({ tag: "xdr:to" }),
             "xdr:pic": new PicXform(),
+            "xdr:sp": new SpXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -16,15 +18,41 @@ class TwoCellAnchorXform extends BaseCellAnchorXform {
         return "xdr:twoCellAnchor";
     }
     prepare(model, options) {
-        this.map["xdr:pic"].prepare(model.picture, options);
+        if (model.picture) {
+            this.map["xdr:pic"].prepare(model.picture, options);
+        }
     }
     render(xmlStream, model) {
+        const wrapAlternateContent = !!model.alternateContent;
+        if (wrapAlternateContent) {
+            xmlStream.openNode("mc:AlternateContent", {
+                "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006"
+            });
+            xmlStream.openNode("mc:Choice", {
+                Requires: model.alternateContent?.requires,
+                ...(model.alternateContent?.requires === "a14"
+                    ? {
+                        "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
+                    }
+                    : {})
+            });
+        }
         xmlStream.openNode(this.tag, { editAs: model.range.editAs || "oneCell" });
         this.map["xdr:from"].render(xmlStream, model.range.tl);
         this.map["xdr:to"].render(xmlStream, model.range.br);
-        this.map["xdr:pic"].render(xmlStream, model.picture);
+        if (model.picture) {
+            this.map["xdr:pic"].render(xmlStream, model.picture);
+        }
+        else if (model.shape) {
+            this.map["xdr:sp"].render(xmlStream, model.shape);
+        }
         this.map["xdr:clientData"].render(xmlStream, {});
         xmlStream.closeNode();
+        if (wrapAlternateContent) {
+            xmlStream.closeNode(); // mc:Choice
+            xmlStream.leafNode("mc:Fallback");
+            xmlStream.closeNode(); // mc:AlternateContent
+        }
     }
     parseClose(name) {
         if (this.parser) {

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

@@ -107,14 +107,22 @@ class VmlDrawingXform extends BaseXform {
         }
         // ClientData - the core of the checkbox control
         xmlStream.openNode("x:ClientData", { ObjectType: "Checkbox" });
+        // Match Excel's VML patterns (similar to Note ClientData): include positioning and cell address.
+        // Omitting these can cause Excel to repair the sheet by dropping all legacy controls.
+        xmlStream.leafNode("x:MoveWithCells");
+        xmlStream.leafNode("x:SizeWithCells");
         // Anchor position
         xmlStream.openNode("x:Anchor");
         xmlStream.writeText(FormCheckbox.getVmlAnchor(control));
         xmlStream.closeNode();
+        // Protection / text locking
+        xmlStream.leafNode("x:Locked", undefined, "False");
+        xmlStream.leafNode("x:LockText", undefined, "True");
         // Print settings
         xmlStream.leafNode("x:PrintObject", undefined, control.print ? "True" : "False");
         xmlStream.leafNode("x:AutoFill", undefined, "False");
         xmlStream.leafNode("x:AutoLine", undefined, "False");
+        xmlStream.leafNode("x:TextHAlign", undefined, "Left");
         xmlStream.leafNode("x:TextVAlign", undefined, "Center");
         // Linked cell
         if (control.link) {
@@ -126,6 +134,9 @@ class VmlDrawingXform extends BaseXform {
         }
         // Checked state (0 = unchecked, 1 = checked, 2 = mixed)
         xmlStream.leafNode("x:Checked", undefined, String(FormCheckbox.getVmlCheckedValue(control)));
+        // Cell address (0-based row/column)
+        xmlStream.leafNode("x:Row", undefined, String(control.tl.row));
+        xmlStream.leafNode("x:Column", undefined, String(control.tl.col));
         xmlStream.closeNode(); // x:ClientData
         xmlStream.closeNode(); // v:shape
     }

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

@@ -41,17 +41,15 @@ class ListXform extends BaseXform {
             this.parser.parseOpen(node);
             return true;
         }
-        switch (node.name) {
-            case this.tag:
-                this.model = [];
-                return true;
-            default:
-                if (this.childXform.parseOpen(node)) {
-                    this.parser = this.childXform;
-                    return true;
-                }
-                return false;
+        if (node.name === this.tag) {
+            this.model = [];
+            return true;
         }
+        if (this.childXform.parseOpen(node)) {
+            this.parser = this.childXform;
+            return true;
+        }
+        return false;
     }
     parseText(text) {
         if (this.parser) {

package/dist/browser/modules/excel/xlsx/xform/sheet/page-setup-xform.d.ts

@@ -19,6 +19,7 @@ interface PageSetupModel {
 }
 declare class PageSetupXform extends BaseXform {
     get tag(): string;
+    private _dpiToXml;
     render(xmlStream: any, model: PageSetupModel): void;
     parseOpen(node: any): boolean;
     parseText(): void;

package/dist/browser/modules/excel/xlsx/xform/sheet/page-setup-xform.js

@@ -36,13 +36,27 @@ class PageSetupXform extends BaseXform {
     get tag() {
         return "pageSetup";
     }
+    _dpiToXml(value) {
+        // Excel commonly omits these attributes. 4294967295 is used as a sentinel default
+        // when parsing missing values; it should never be serialized back out.
+        if (value === undefined) {
+            return undefined;
+        }
+        if (!Number.isFinite(value)) {
+            return undefined;
+        }
+        if (value === 4294967295) {
+            return undefined;
+        }
+        return value;
+    }
     render(xmlStream, model) {
         if (model) {
             const attributes = {
                 paperSize: model.paperSize,
                 orientation: model.orientation,
-                horizontalDpi: model.horizontalDpi,
-                verticalDpi: model.verticalDpi,
+                horizontalDpi: this._dpiToXml(model.horizontalDpi),
+                verticalDpi: this._dpiToXml(model.verticalDpi),
                 pageOrder: pageOrderToXml(model.pageOrder),
                 blackAndWhite: booleanToXml(model.blackAndWhite),
                 draft: booleanToXml(model.draft),