@cj-tech-master/excelts 4.0.4 → 4.1.0-canary.20260110032830.e7d8c4e

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

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmlDrawingXform = void 0;
+const xml_stream_1 = require("../../../utils/xml-stream.js");
+const base_xform_1 = require("../base-xform.js");
+const vml_shape_xform_1 = require("../comment/vml-shape-xform.js");
+const form_control_1 = require("../../../form-control.js");
+class VmlDrawingXform extends base_xform_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "v:shape": new vml_shape_xform_1.VmlShapeXform()
+        };
+        this.model = { comments: [], formControls: [] };
+    }
+    get tag() {
+        return "xml";
+    }
+    /**
+     * Render VML drawing containing both notes and form controls
+     */
+    render(xmlStream, model) {
+        const renderModel = model || this.model;
+        const hasComments = renderModel.comments && renderModel.comments.length > 0;
+        const hasFormControls = renderModel.formControls && renderModel.formControls.length > 0;
+        xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
+        xmlStream.openNode(this.tag, VmlDrawingXform.DRAWING_ATTRIBUTES);
+        // Shape layout - shared by both notes and form controls
+        xmlStream.openNode("o:shapelayout", { "v:ext": "edit" });
+        xmlStream.leafNode("o:idmap", { "v:ext": "edit", data: 1 });
+        xmlStream.closeNode();
+        // Shapetype 202 for notes/comments
+        if (hasComments) {
+            xmlStream.openNode("v:shapetype", {
+                id: "_x0000_t202",
+                coordsize: "21600,21600",
+                "o:spt": 202,
+                path: "m,l,21600r21600,l21600,xe"
+            });
+            xmlStream.leafNode("v:stroke", { joinstyle: "miter" });
+            xmlStream.leafNode("v:path", { gradientshapeok: "t", "o:connecttype": "rect" });
+            xmlStream.closeNode();
+        }
+        // Shapetype 201 for form control checkboxes
+        if (hasFormControls) {
+            xmlStream.openNode("v:shapetype", {
+                id: "_x0000_t201",
+                coordsize: "21600,21600",
+                "o:spt": "201",
+                path: "m,l,21600r21600,l21600,xe"
+            });
+            xmlStream.leafNode("v:stroke", { joinstyle: "miter" });
+            xmlStream.leafNode("v:path", {
+                shadowok: "f",
+                "o:extrusionok": "f",
+                strokeok: "f",
+                fillok: "f",
+                "o:connecttype": "rect"
+            });
+            xmlStream.leafNode("o:lock", { "v:ext": "edit", shapetype: "t" });
+            xmlStream.closeNode();
+        }
+        // Render comment shapes
+        if (hasComments) {
+            const comments = renderModel.comments;
+            for (let i = 0; i < comments.length; i++) {
+                this.map["v:shape"].render(xmlStream, comments[i], i);
+            }
+        }
+        // Render form control shapes
+        if (hasFormControls) {
+            for (const control of renderModel.formControls) {
+                this._renderCheckboxShape(xmlStream, control);
+            }
+        }
+        xmlStream.closeNode();
+    }
+    /**
+     * Render a checkbox form control shape
+     */
+    _renderCheckboxShape(xmlStream, control) {
+        const shapeAttrs = {
+            id: `_x0000_s${control.shapeId}`,
+            type: "#_x0000_t201",
+            style: form_control_1.FormCheckbox.getVmlStyle(control),
+            "o:insetmode": "auto",
+            fillcolor: "buttonFace [67]",
+            strokecolor: "windowText [64]",
+            "o:preferrelative": "t",
+            filled: "f",
+            stroked: "f"
+        };
+        xmlStream.openNode("v:shape", shapeAttrs);
+        // Fill element
+        xmlStream.leafNode("v:fill", { "o:detectmouseclick": "t" });
+        // Lock element
+        xmlStream.leafNode("o:lock", { "v:ext": "edit", text: "t" });
+        // Textbox for label
+        if (control.text) {
+            xmlStream.openNode("v:textbox", {
+                style: "mso-direction-alt:auto",
+                "o:singleclick": "t"
+            });
+            xmlStream.openNode("div", { style: "text-align:left" });
+            xmlStream.openNode("font", { face: "Tahoma", size: "160", color: "auto" });
+            xmlStream.writeText(control.text);
+            xmlStream.closeNode(); // font
+            xmlStream.closeNode(); // div
+            xmlStream.closeNode(); // v:textbox
+        }
+        // ClientData - the core of the checkbox control
+        xmlStream.openNode("x:ClientData", { ObjectType: "Checkbox" });
+        // Anchor position
+        xmlStream.openNode("x:Anchor");
+        xmlStream.writeText(form_control_1.FormCheckbox.getVmlAnchor(control));
+        xmlStream.closeNode();
+        // 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:TextVAlign", undefined, "Center");
+        // Linked cell
+        if (control.link) {
+            xmlStream.leafNode("x:FmlaLink", undefined, control.link);
+        }
+        // 3D appearance
+        if (control.noThreeD) {
+            xmlStream.leafNode("x:NoThreeD");
+        }
+        // Checked state (0 = unchecked, 1 = checked, 2 = mixed)
+        xmlStream.leafNode("x:Checked", undefined, String(form_control_1.FormCheckbox.getVmlCheckedValue(control)));
+        xmlStream.closeNode(); // x:ClientData
+        xmlStream.closeNode(); // v:shape
+    }
+    // Parsing - delegate to VmlShapeXform for notes
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {
+                    comments: [],
+                    formControls: []
+                };
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.model.comments.push(this.parser.model);
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+exports.VmlDrawingXform = VmlDrawingXform;
+VmlDrawingXform.DRAWING_ATTRIBUTES = {
+    "xmlns:v": "urn:schemas-microsoft-com:vml",
+    "xmlns:o": "urn:schemas-microsoft-com:office:office",
+    "xmlns:x": "urn:schemas-microsoft-com:office:excel"
+};

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

@@ -192,6 +192,11 @@ class CellXform extends base_xform_1.BaseXform {
                 xmlStream.addAttribute("t", "b");
                 xmlStream.leafNode("v", null, model.value ? "1" : "0");
                 break;
+            case enums_1.Enums.ValueType.Checkbox:
+                // Checkboxes are stored as boolean values
+                xmlStream.addAttribute("t", "b");
+                xmlStream.leafNode("v", null, model.value ? "1" : "0");
+                break;
             case enums_1.Enums.ValueType.Error:
                 xmlStream.addAttribute("t", "e");
                 xmlStream.leafNode("v", null, model.value.error);

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

@@ -278,6 +278,29 @@ class WorkSheetXform extends base_xform_1.BaseXform {
                 Target: (0, ooxml_paths_1.pivotTableRelTargetFromWorksheet)(pivotTable.tableNumber)
             });
         });
+        // prepare form controls (legacy checkboxes)
+        // Form controls share the VML file with comments, but need separate ctrlProp relationships
+        if (model.formControls && model.formControls.length > 0) {
+            // If no comments, we need to add the VML drawing relationship for form controls
+            if (model.comments.length === 0) {
+                rels.push({
+                    Id: nextRid(rels),
+                    Type: rel_type_1.RelType.VmlDrawing,
+                    Target: (0, ooxml_paths_1.vmlDrawingRelTargetFromWorksheet)(model.id)
+                });
+            }
+            // Add ctrlProp relationships for each form control
+            for (const control of model.formControls) {
+                const globalCtrlPropId = options.formControlRefs.length + 1;
+                control.ctrlPropId = globalCtrlPropId;
+                rels.push({
+                    Id: nextRid(rels),
+                    Type: rel_type_1.RelType.CtrlProp,
+                    Target: (0, ooxml_paths_1.ctrlPropRelTargetFromWorksheet)(globalCtrlPropId)
+                });
+                options.formControlRefs.push(globalCtrlPropId);
+            }
+        }
         // prepare ext items
         this.map.extLst.prepare(model, options);
     }

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

@@ -55,6 +55,17 @@ class StyleXform extends base_xform_1.BaseXform {
         if (model.protection) {
             this.map.protection.render(xmlStream, model.protection);
         }
+        // Add checkbox extLst if needed
+        if (model.checkbox && model.xfComplementIndex !== undefined) {
+            xmlStream.openNode("extLst");
+            xmlStream.openNode("ext", {
+                "xmlns:xfpb": "http://schemas.microsoft.com/office/spreadsheetml/2022/featurepropertybag",
+                uri: "{C7286773-470A-42A8-94C5-96B5CB345126}"
+            });
+            xmlStream.leafNode("xfpb:xfComplement", { i: model.xfComplementIndex });
+            xmlStream.closeNode();
+            xmlStream.closeNode();
+        }
         xmlStream.closeNode();
     }
     parseOpen(node) {

package/dist/cjs/modules/excel/xlsx/xform/style/styles-xform.js

@@ -85,6 +85,7 @@ class StylesXform extends base_xform_1.BaseXform {
         this._addFill({ type: "pattern", pattern: "none" });
         this._addFill({ type: "pattern", pattern: "gray125" });
         this.weakMap = new WeakMap();
+        this._hasCheckboxes = false;
     }
     render(xmlStream, model) {
         const renderModel = model || this.model;
@@ -225,12 +226,15 @@ class StylesXform extends base_xform_1.BaseXform {
             // default (zero) font
             this._addFont({ size: 11, color: { theme: 1 }, name: "Calibri", family: 2, scheme: "minor" });
         }
-        // if we have seen this style object before, assume it has the same styleId
-        if (this.weakMap && this.weakMap.has(model)) {
+        const type = cellType || enums_1.Enums.ValueType.Number;
+        // If we have seen this style object before, assume it has the same styleId.
+        // Do not cache by object identity for checkbox cells because the styleId must
+        // include checkbox-specific extLst, and the same style object may be reused
+        // for non-checkbox cells.
+        if (type !== enums_1.Enums.ValueType.Checkbox && this.weakMap && this.weakMap.has(model)) {
             return this.weakMap.get(model);
         }
         const style = {};
-        const type = cellType || enums_1.Enums.ValueType.Number;
         if (model.numFmt) {
             style.numFmtId = this._addNumFmtStr(model.numFmt);
         }
@@ -261,8 +265,17 @@ class StylesXform extends base_xform_1.BaseXform {
         if (model.protection) {
             style.protection = model.protection;
         }
+        if (type === enums_1.Enums.ValueType.Checkbox) {
+            // Checkbox rendering relies on style extensions (extLst) and workbook-level parts.
+            // Force applyAlignment="1" (without emitting an <alignment/> node) by providing
+            // an empty alignment object when none is specified.
+            this._hasCheckboxes = true;
+            style.alignment = style.alignment || {};
+            style.checkbox = true;
+            style.xfComplementIndex = 0;
+        }
         const styleId = this._addStyle(style);
-        if (this.weakMap) {
+        if (type !== enums_1.Enums.ValueType.Checkbox && this.weakMap) {
             this.weakMap.set(model, styleId);
         }
         return styleId;
@@ -325,6 +338,10 @@ class StylesXform extends base_xform_1.BaseXform {
     getDxfStyle(id) {
         return this.model.dxfs[id];
     }
+    // Check if workbook uses checkbox feature
+    get hasCheckboxes() {
+        return !!this._hasCheckboxes;
+    }
     // =========================================================================
     // Private Interface
     _addStyle(style) {
@@ -461,12 +478,19 @@ class StylesXformMock extends StylesXform {
     // the styleId is returned. Note: cellType is used when numFmt not defined
     addStyleModel(model, cellType) {
         switch (cellType) {
+            case enums_1.Enums.ValueType.Checkbox:
+                // Checkbox rendering relies on style extensions (extLst) and workbook-level parts.
+                // The mock style manager intentionally does not build those structures.
+                throw new Error("Checkbox cells require styles to be enabled (useStyles: true)");
             case enums_1.Enums.ValueType.Date:
                 return this.dateStyleId;
             default:
                 return 0;
         }
     }
+    get hasCheckboxes() {
+        return false;
+    }
     get dateStyleId() {
         if (!this._dateStyleId) {
             const dateStyle = {

package/dist/cjs/modules/excel/xlsx/xlsx.browser.js

@@ -20,13 +20,15 @@ const content_types_xform_1 = require("./xform/core/content-types-xform.js");
 const app_xform_1 = require("./xform/core/app-xform.js");
 const workbook_xform_1 = require("./xform/book/workbook-xform.js");
 const worksheet_xform_1 = require("./xform/sheet/worksheet-xform.js");
+const feature_property_bag_xform_1 = require("./xform/core/feature-property-bag-xform.js");
 const drawing_xform_1 = require("./xform/drawing/drawing-xform.js");
 const table_xform_1 = require("./xform/table/table-xform.js");
 const pivot_cache_records_xform_1 = require("./xform/pivot-table/pivot-cache-records-xform.js");
 const pivot_cache_definition_xform_1 = require("./xform/pivot-table/pivot-cache-definition-xform.js");
 const pivot_table_xform_1 = require("./xform/pivot-table/pivot-table-xform.js");
 const comments_xform_1 = require("./xform/comment/comments-xform.js");
-const vml_notes_xform_1 = require("./xform/comment/vml-notes-xform.js");
+const vml_drawing_xform_1 = require("./xform/drawing/vml-drawing-xform.js");
+const ctrl_prop_xform_1 = require("./xform/drawing/ctrl-prop-xform.js");
 const theme1_1 = require("./xml/theme1.js");
 const rel_type_1 = require("./rel-type.js");
 const stream_buf_1 = require("../utils/stream-buf.js");
@@ -206,6 +208,7 @@ class XLSX {
         this.addTables(zip, model);
         this.addPivotTables(zip, model);
         await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
+        await this.addFeaturePropertyBag(zip, model);
         await this.addMedia(zip, model);
         await Promise.all([this.addApp(zip, model), this.addCore(zip, model)]);
         await this.addWorkbook(zip, model);
@@ -703,7 +706,7 @@ class XLSX {
         model.drawingRels[name] = relationships;
     }
     async _processVmlDrawingEntry(entry, model, name) {
-        const xform = new vml_notes_xform_1.VmlNotesXform();
+        const xform = new vml_drawing_xform_1.VmlDrawingXform();
         const vmlDrawing = await xform.parseStream(entry);
         model.vmlDrawings[(0, ooxml_paths_1.vmlDrawingRelTargetFromWorksheetName)(name)] = vmlDrawing;
     }
@@ -974,6 +977,14 @@ class XLSX {
                 Target: ooxml_paths_1.OOXML_REL_TARGETS.workbookSharedStrings
             });
         }
+        // Add FeaturePropertyBag relationship if checkboxes are used
+        if (model.hasCheckboxes) {
+            relationships.push({
+                Id: `rId${count++}`,
+                Type: XLSX.RelType.FeaturePropertyBag,
+                Target: ooxml_paths_1.OOXML_REL_TARGETS.workbookFeaturePropertyBag
+            });
+        }
         (model.pivotTables || []).forEach((pivotTable) => {
             pivotTable.rId = `rId${count++}`;
             relationships.push({
@@ -995,6 +1006,13 @@ class XLSX {
         const xml = xform.toXml(relationships);
         zip.append(xml, { name: ooxml_paths_1.OOXML_PATHS.xlWorkbookRels });
     }
+    async addFeaturePropertyBag(zip, model) {
+        if (!model.hasCheckboxes) {
+            return;
+        }
+        const xform = new feature_property_bag_xform_1.FeaturePropertyBagXform();
+        zip.append(xform.toXml({}), { name: ooxml_paths_1.OOXML_PATHS.xlFeaturePropertyBag });
+    }
     async addSharedStrings(zip, model) {
         if (model.sharedStrings && model.sharedStrings.count) {
             zip.append(model.sharedStrings.xml, { name: ooxml_paths_1.OOXML_PATHS.xlSharedStrings });
@@ -1014,7 +1032,8 @@ class XLSX {
         const worksheetXform = new worksheet_xform_1.WorkSheetXform();
         const relationshipsXform = new relationships_xform_1.RelationshipsXform();
         const commentsXform = new comments_xform_1.CommentsXform();
-        const vmlNotesXform = new vml_notes_xform_1.VmlNotesXform();
+        const vmlDrawingXform = new vml_drawing_xform_1.VmlDrawingXform();
+        const ctrlPropXform = new ctrl_prop_xform_1.CtrlPropXform();
         model.worksheets.forEach((worksheet, index) => {
             const fileIndex = worksheet.fileIndex || index + 1;
             let xmlStream = new xml_stream_1.XmlStream();
@@ -1025,14 +1044,30 @@ class XLSX {
                 relationshipsXform.render(xmlStream, worksheet.rels);
                 zip.append(xmlStream.xml, { name: (0, ooxml_paths_1.worksheetRelsPath)(fileIndex) });
             }
+            // Generate comments XML (separate from VML)
             if (worksheet.comments.length > 0) {
                 xmlStream = new xml_stream_1.XmlStream();
                 commentsXform.render(xmlStream, worksheet);
                 zip.append(xmlStream.xml, { name: (0, ooxml_paths_1.commentsPath)(fileIndex) });
+            }
+            // Generate unified VML drawing (contains both notes and form controls)
+            const hasComments = worksheet.comments.length > 0;
+            const hasFormControls = worksheet.formControls && worksheet.formControls.length > 0;
+            if (hasComments || hasFormControls) {
                 xmlStream = new xml_stream_1.XmlStream();
-                vmlNotesXform.render(xmlStream, worksheet);
+                vmlDrawingXform.render(xmlStream, {
+                    comments: hasComments ? worksheet.comments : [],
+                    formControls: hasFormControls ? worksheet.formControls : []
+                });
                 zip.append(xmlStream.xml, { name: (0, ooxml_paths_1.vmlDrawingPath)(fileIndex) });
             }
+            // Generate ctrlProp files for form controls
+            if (hasFormControls) {
+                worksheet.formControls.forEach((control) => {
+                    const xml = ctrlPropXform.toXml(control);
+                    zip.append(xml, { name: (0, ooxml_paths_1.ctrlPropPath)(control.ctrlPropId) });
+                });
+            }
         });
     }
     addDrawings(zip, model) {
@@ -1138,6 +1173,7 @@ class XLSX {
         };
         worksheetOptions.drawings = model.drawings = [];
         worksheetOptions.commentRefs = model.commentRefs = [];
+        worksheetOptions.formControlRefs = model.formControlRefs = [];
         let tableCount = 0;
         model.tables = [];
         model.worksheets.forEach((worksheet) => {
@@ -1149,6 +1185,8 @@ class XLSX {
             });
             worksheetXform.prepare(worksheet, worksheetOptions);
         });
+        // ContentTypesXform expects this flag
+        model.hasCheckboxes = model.styles.hasCheckboxes;
     }
 }
 exports.XLSX = XLSX;

package/dist/esm/index.browser.js

@@ -15,6 +15,7 @@ export { Image } from "./modules/excel/image.js";
 export * from "./modules/excel/anchor.js";
 export { Table } from "./modules/excel/table.js";
 export { DataValidations } from "./modules/excel/data-validations.js";
+export { FormCheckbox } from "./modules/excel/form-control.js";
 // =============================================================================
 // Enums
 // =============================================================================

package/dist/esm/index.js

@@ -11,6 +11,7 @@ export { Image } from "./modules/excel/image.js";
 export * from "./modules/excel/anchor.js";
 export { Table } from "./modules/excel/table.js";
 export { DataValidations } from "./modules/excel/data-validations.js";
+export { FormCheckbox } from "./modules/excel/form-control.js";
 // =============================================================================
 // Node.js Only: Streaming Classes
 // These can also be accessed via Workbook.createStreamWriter/createStreamReader

package/dist/esm/modules/excel/cell.js

@@ -809,6 +809,40 @@ class BooleanValue {
         return this.model.value.toString();
     }
 }
+class CheckboxValue {
+    constructor(cell, value) {
+        this.model = {
+            address: cell.address,
+            type: Cell.Types.Checkbox,
+            value: value.checkbox
+        };
+    }
+    get value() {
+        return { checkbox: this.model.value };
+    }
+    set value(value) {
+        this.model.value = value.checkbox;
+    }
+    get type() {
+        return Cell.Types.Checkbox;
+    }
+    get effectiveType() {
+        return Cell.Types.Boolean;
+    }
+    get address() {
+        return this.model.address;
+    }
+    set address(value) {
+        this.model.address = value;
+    }
+    toCsvString() {
+        return this.model.value ? 1 : 0;
+    }
+    release() { }
+    toString() {
+        return this.model.value.toString();
+    }
+}
 class ErrorValue {
     constructor(cell, value) {
         this.model = {
@@ -898,6 +932,9 @@ const Value = {
             return Cell.Types.Date;
         }
         if (typeof value === "object") {
+            if ("checkbox" in value && typeof value.checkbox === "boolean") {
+                return Cell.Types.Checkbox;
+            }
             if ("text" in value && value.text && "hyperlink" in value && value.hyperlink) {
                 return Cell.Types.Hyperlink;
             }
@@ -930,7 +967,8 @@ const Value = {
         { t: Cell.Types.SharedString, f: SharedStringValue },
         { t: Cell.Types.RichText, f: RichTextValue },
         { t: Cell.Types.Boolean, f: BooleanValue },
-        { t: Cell.Types.Error, f: ErrorValue }
+        { t: Cell.Types.Error, f: ErrorValue },
+        { t: Cell.Types.Checkbox, f: CheckboxValue }
     ].reduce((p, t) => {
         p[t.t] = t.f;
         return p;

package/dist/esm/modules/excel/enums.js

@@ -11,7 +11,8 @@ export var ValueType;
     ValueType[ValueType["RichText"] = 8] = "RichText";
     ValueType[ValueType["Boolean"] = 9] = "Boolean";
     ValueType[ValueType["Error"] = 10] = "Error";
-    ValueType[ValueType["JSON"] = 11] = "JSON"; // Internal type for JSON values that serialize as String
+    ValueType[ValueType["JSON"] = 11] = "JSON";
+    ValueType[ValueType["Checkbox"] = 12] = "Checkbox";
 })(ValueType || (ValueType = {}));
 export var FormulaType;
 (function (FormulaType) {