@cj-tech-master/excelts 4.1.0 → 4.2.0-canary.20260110080706.375ff37

package/dist/cjs/modules/excel/form-control.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormCheckbox = exports.EMU_PER_POINT = exports.EMU_PER_PIXEL = void 0;
+const col_cache_1 = require("./utils/col-cache.js");
+/**
+ * Form Control Checkbox - Legacy checkbox control compatible with Office 2007+ and WPS/LibreOffice
+ *
+ * Unlike the modern In-Cell Checkbox (which only works in Microsoft 365),
+ * Form Control Checkboxes are floating controls that work in virtually all
+ * spreadsheet applications.
+ */
+// ============================================================================
+// Constants (exported for use by xforms)
+// ============================================================================
+/** EMU (English Metric Units) to pixels conversion factor at 96 DPI */
+exports.EMU_PER_PIXEL = 9525;
+/** EMU to points conversion factor */
+exports.EMU_PER_POINT = 12700;
+/** Default column offset in EMUs (~15 pixels) */
+const DEFAULT_COL_OFF = 142875;
+/** Default row offset in EMUs (~3 pixels) */
+const DEFAULT_ROW_OFF = 28575;
+/** Default end column offset in EMUs (~29 pixels) */
+const DEFAULT_END_COL_OFF = 276225;
+/** Default end row offset in EMUs (~20 pixels) */
+const DEFAULT_END_ROW_OFF = 190500;
+// ============================================================================
+// FormCheckbox Class
+// ============================================================================
+class FormCheckbox {
+    constructor(worksheet, range, options) {
+        this.worksheet = worksheet;
+        // Parse range to get anchors
+        const { tl, br } = this._parseRange(range);
+        // Generate shape ID (starting from 1025)
+        const existingCount = worksheet.formControls?.length || 0;
+        const shapeId = 1025 + existingCount;
+        // Parse link cell reference
+        let link;
+        if (options?.link) {
+            // Ensure absolute reference format
+            link = this._toAbsoluteRef(options.link);
+        }
+        // Note: ctrlPropId is set later in worksheet-xform.ts prepare() for global uniqueness
+        this.model = {
+            shapeId,
+            ctrlPropId: 0, // Placeholder, set during prepare()
+            tl,
+            br,
+            link,
+            checked: options?.checked ? "Checked" : "Unchecked",
+            text: options?.text ?? "",
+            noThreeD: options?.noThreeD ?? true,
+            print: options?.print ?? false
+        };
+    }
+    /**
+     * Get the checked state
+     */
+    get checked() {
+        return this.model.checked === "Checked";
+    }
+    /**
+     * Set the checked state
+     */
+    set checked(value) {
+        this.model.checked = value ? "Checked" : "Unchecked";
+    }
+    /**
+     * Get the linked cell address
+     */
+    get link() {
+        return this.model.link;
+    }
+    /**
+     * Set the linked cell address
+     */
+    set link(value) {
+        this.model.link = value ? this._toAbsoluteRef(value) : undefined;
+    }
+    /**
+     * Get the label text
+     */
+    get text() {
+        return this.model.text;
+    }
+    /**
+     * Set the label text
+     */
+    set text(value) {
+        this.model.text = value;
+    }
+    /**
+     * Convert cell reference to absolute format (e.g., "A1" -> "$A$1")
+     */
+    _toAbsoluteRef(ref) {
+        // If already absolute, return as-is
+        if (ref.includes("$")) {
+            return ref;
+        }
+        // Parse and convert
+        const addr = col_cache_1.colCache.decodeAddress(ref);
+        return `$${col_cache_1.colCache.n2l(addr.col)}$${addr.row}`;
+    }
+    /**
+     * Parse range input into anchor positions
+     */
+    _parseRange(range) {
+        let tl;
+        let br;
+        if (typeof range === "string") {
+            // Parse cell reference like "B2" or "B2:D3"
+            const decoded = col_cache_1.colCache.decode(range);
+            if ("top" in decoded) {
+                // It's a range like "B2:D3"
+                tl = {
+                    col: decoded.left - 1, // Convert to 0-based
+                    colOff: DEFAULT_COL_OFF,
+                    row: decoded.top - 1,
+                    rowOff: DEFAULT_ROW_OFF
+                };
+                br = {
+                    col: decoded.right - 1,
+                    colOff: DEFAULT_END_COL_OFF,
+                    row: decoded.bottom - 1,
+                    rowOff: DEFAULT_END_ROW_OFF
+                };
+            }
+            else {
+                // Single cell reference - create default size checkbox
+                tl = {
+                    col: decoded.col - 1,
+                    colOff: DEFAULT_COL_OFF,
+                    row: decoded.row - 1,
+                    rowOff: DEFAULT_ROW_OFF
+                };
+                // Default size: about 2 columns wide, 1 row tall
+                br = {
+                    col: decoded.col + 1,
+                    colOff: DEFAULT_END_COL_OFF,
+                    row: decoded.row,
+                    rowOff: DEFAULT_END_ROW_OFF
+                };
+            }
+        }
+        else if ("startCol" in range) {
+            // startCol/startRow/endCol/endRow format (0-based)
+            tl = {
+                col: range.startCol,
+                colOff: range.startColOff ?? DEFAULT_COL_OFF,
+                row: range.startRow,
+                rowOff: range.startRowOff ?? DEFAULT_ROW_OFF
+            };
+            br = {
+                col: range.endCol,
+                colOff: range.endColOff ?? DEFAULT_END_COL_OFF,
+                row: range.endRow,
+                rowOff: range.endRowOff ?? DEFAULT_END_ROW_OFF
+            };
+        }
+        else {
+            // Object format with tl/br
+            if (typeof range.tl === "string") {
+                const decoded = col_cache_1.colCache.decodeAddress(range.tl);
+                tl = {
+                    col: decoded.col - 1,
+                    colOff: DEFAULT_COL_OFF,
+                    row: decoded.row - 1,
+                    rowOff: DEFAULT_ROW_OFF
+                };
+            }
+            else {
+                tl = {
+                    col: range.tl.col,
+                    colOff: range.tl.colOff ?? DEFAULT_COL_OFF,
+                    row: range.tl.row,
+                    rowOff: range.tl.rowOff ?? DEFAULT_ROW_OFF
+                };
+            }
+            if (range.br) {
+                if (typeof range.br === "string") {
+                    const decoded = col_cache_1.colCache.decodeAddress(range.br);
+                    br = {
+                        col: decoded.col - 1,
+                        colOff: DEFAULT_END_COL_OFF,
+                        row: decoded.row - 1,
+                        rowOff: DEFAULT_END_ROW_OFF
+                    };
+                }
+                else {
+                    br = {
+                        col: range.br.col,
+                        colOff: range.br.colOff ?? DEFAULT_END_COL_OFF,
+                        row: range.br.row,
+                        rowOff: range.br.rowOff ?? DEFAULT_END_ROW_OFF
+                    };
+                }
+            }
+            else {
+                // Default size
+                br = {
+                    col: tl.col + 2,
+                    colOff: DEFAULT_END_COL_OFF,
+                    row: tl.row + 1,
+                    rowOff: DEFAULT_END_ROW_OFF
+                };
+            }
+        }
+        return { tl, br };
+    }
+    // =========================================================================
+    // Instance methods - delegate to static methods
+    // =========================================================================
+    /**
+     * Convert anchor to VML anchor string format
+     * Format: "fromCol, fromColOff, fromRow, fromRowOff, toCol, toColOff, toRow, toRowOff"
+     * VML uses pixels for offsets
+     */
+    getVmlAnchor() {
+        return FormCheckbox.getVmlAnchor(this.model);
+    }
+    /**
+     * Get VML style string for positioning
+     */
+    getVmlStyle() {
+        return FormCheckbox.getVmlStyle(this.model);
+    }
+    /**
+     * Get the numeric checked value for VML (0, 1, or 2)
+     */
+    getVmlCheckedValue() {
+        return FormCheckbox.getVmlCheckedValue(this.model);
+    }
+    // =========================================================================
+    // Static utility methods - can be used with FormCheckboxModel directly
+    // =========================================================================
+    /**
+     * Convert anchor to VML anchor string format from model
+     */
+    static getVmlAnchor(model) {
+        const { tl, br } = model;
+        const tlColOff = Math.round(tl.colOff / exports.EMU_PER_PIXEL);
+        const tlRowOff = Math.round(tl.rowOff / exports.EMU_PER_PIXEL);
+        const brColOff = Math.round(br.colOff / exports.EMU_PER_PIXEL);
+        const brRowOff = Math.round(br.rowOff / exports.EMU_PER_PIXEL);
+        return `${tl.col}, ${tlColOff}, ${tl.row}, ${tlRowOff}, ${br.col}, ${brColOff}, ${br.row}, ${brRowOff}`;
+    }
+    /**
+     * Get VML style string for positioning from model
+     */
+    static getVmlStyle(model) {
+        const marginLeft = Math.round(model.tl.colOff / exports.EMU_PER_POINT);
+        const marginTop = Math.round(model.tl.rowOff / exports.EMU_PER_POINT);
+        return `position:absolute;margin-left:${marginLeft}pt;margin-top:${marginTop}pt;width:96pt;height:18pt;z-index:1;visibility:visible`;
+    }
+    /**
+     * Get the numeric checked value for VML from model (0, 1, or 2)
+     */
+    static getVmlCheckedValue(model) {
+        switch (model.checked) {
+            case "Checked":
+                return 1;
+            case "Mixed":
+                return 2;
+            default:
+                return 0;
+        }
+    }
+}
+exports.FormCheckbox = FormCheckbox;

package/dist/cjs/modules/excel/utils/ooxml-paths.js

@@ -49,6 +49,8 @@ exports.pivotTableRelTargetFromWorksheetName = pivotTableRelTargetFromWorksheetN
 exports.tableRelTargetFromWorksheet = tableRelTargetFromWorksheet;
 exports.tableRelTargetFromWorksheetName = tableRelTargetFromWorksheetName;
 exports.mediaRelTargetFromRels = mediaRelTargetFromRels;
+exports.ctrlPropPath = ctrlPropPath;
+exports.ctrlPropRelTargetFromWorksheet = ctrlPropRelTargetFromWorksheet;
 exports.OOXML_PATHS = {
     contentTypes: "[Content_Types].xml",
     rootRels: "_rels/.rels",
@@ -260,3 +262,11 @@ function mediaRelTargetFromRels(filename) {
     // Target from a rels file located under xl/*/_rels (base is one level deeper than xl/)
     return `../media/${filename}`;
 }
+// Form Control (ctrlProps) path functions
+function ctrlPropPath(id) {
+    return `xl/ctrlProps/ctrlProp${id}.xml`;
+}
+function ctrlPropRelTargetFromWorksheet(id) {
+    // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
+    return `../ctrlProps/ctrlProp${id}.xml`;
+}

package/dist/cjs/modules/excel/worksheet.js

@@ -9,6 +9,7 @@ const enums_1 = require("./enums.js");
 const image_1 = require("./image.js");
 const table_1 = require("./table.js");
 const data_validations_1 = require("./data-validations.js");
+const form_control_1 = require("./form-control.js");
 const encryptor_1 = require("./utils/encryptor.js");
 const utils_1 = require("../../utils/utils.js");
 const pivot_table_1 = require("./pivot-table.js");
@@ -95,6 +96,8 @@ class Worksheet {
         this.tables = {};
         this.pivotTables = [];
         this.conditionalFormattings = [];
+        // for form controls (legacy checkboxes, etc.)
+        this.formControls = [];
     }
     get name() {
         return this._name;
@@ -748,6 +751,43 @@ class Worksheet {
         return image && image.imageId;
     }
     // =========================================================================
+    // Form Controls (Legacy Checkboxes)
+    /**
+     * Add a form control checkbox to the worksheet.
+     *
+     * Form control checkboxes are the legacy style that work in Office 2007+,
+     * WPS Office, LibreOffice, and other spreadsheet applications.
+     *
+     * Unlike modern in-cell checkboxes (which only work in Microsoft 365),
+     * form control checkboxes are floating controls positioned over cells.
+     *
+     * @param range - Cell reference (e.g., "B2") or range (e.g., "B2:D3") for positioning
+     * @param options - Checkbox options
+     * @returns The created FormCheckbox instance
+     *
+     * @example
+     * // Simple checkbox at B2
+     * ws.addFormCheckbox("B2");
+     *
+     * // Checkbox with label and linked cell
+     * ws.addFormCheckbox("B2:D3", {
+     *   text: "Accept terms",
+     *   link: "A2",
+     *   checked: false
+     * });
+     */
+    addFormCheckbox(range, options) {
+        const checkbox = new form_control_1.FormCheckbox(this, range, options);
+        this.formControls.push(checkbox);
+        return checkbox;
+    }
+    /**
+     * Get all form control checkboxes in the worksheet
+     */
+    getFormCheckboxes() {
+        return this.formControls;
+    }
+    // =========================================================================
     // Worksheet Protection
     /**
      * Protect the worksheet with optional password and options
@@ -856,7 +896,8 @@ class Worksheet {
             sheetProtection: this.sheetProtection,
             tables: Object.values(this.tables).map(table => table.model),
             pivotTables: this.pivotTables,
-            conditionalFormattings: this.conditionalFormattings
+            conditionalFormattings: this.conditionalFormattings,
+            formControls: this.formControls.map(fc => fc.model)
         };
         // =================================================
         // columns
@@ -922,6 +963,8 @@ class Worksheet {
         }, {});
         this.pivotTables = value.pivotTables;
         this.conditionalFormattings = value.conditionalFormattings;
+        // Form controls are currently write-only (not parsed from XLSX)
+        this.formControls = [];
     }
 }
 exports.Worksheet = Worksheet;

package/dist/cjs/modules/excel/xlsx/rel-type.js

@@ -18,6 +18,7 @@ const RelType = {
     PivotCacheDefinition: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition",
     PivotCacheRecords: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheRecords",
     PivotTable: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable",
-    FeaturePropertyBag: "http://schemas.microsoft.com/office/2022/11/relationships/FeaturePropertyBag"
+    FeaturePropertyBag: "http://schemas.microsoft.com/office/2022/11/relationships/FeaturePropertyBag",
+    CtrlProp: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/ctrlProp"
 };
 exports.RelType = RelType;

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

@@ -108,6 +108,22 @@ class ContentTypesXform extends base_xform_1.BaseXform {
                 });
             });
         }
+        // Add form control (ctrlProps) content types
+        if (model.formControlRefs) {
+            // Ensure vml extension is declared (may already be declared for comments)
+            if (!model.commentRefs) {
+                xmlStream.leafNode("Default", {
+                    Extension: "vml",
+                    ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing"
+                });
+            }
+            for (const ctrlPropId of model.formControlRefs) {
+                xmlStream.leafNode("Override", {
+                    PartName: (0, ooxml_paths_1.toContentTypesPartName)((0, ooxml_paths_1.ctrlPropPath)(ctrlPropId)),
+                    ContentType: "application/vnd.ms-excel.controlproperties+xml"
+                });
+            }
+        }
         xmlStream.leafNode("Override", {
             PartName: (0, ooxml_paths_1.toContentTypesPartName)(ooxml_paths_1.OOXML_PATHS.docPropsCore),
             ContentType: "application/vnd.openxmlformats-package.core-properties+xml"

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CtrlPropXform = void 0;
+const xml_stream_1 = require("../../../utils/xml-stream.js");
+const base_xform_1 = require("../base-xform.js");
+/**
+ * Control Properties Xform - Generates ctrlProp*.xml for form controls
+ *
+ * Each form control (checkbox, button, etc.) has an associated ctrlProp file
+ * that stores its properties like objectType, checked state, and linked cell.
+ */
+class CtrlPropXform extends base_xform_1.BaseXform {
+    get tag() {
+        return "formControlPr";
+    }
+    render(xmlStream, model) {
+        const renderModel = model || this.model;
+        const attrs = {
+            xmlns: "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main",
+            objectType: "CheckBox",
+            checked: renderModel.checked,
+            lockText: "1"
+        };
+        // Add linked cell reference
+        if (renderModel.link) {
+            attrs.fmlaLink = renderModel.link;
+        }
+        // Add noThreeD for flat appearance
+        if (renderModel.noThreeD) {
+            attrs.noThreeD = "1";
+        }
+        xmlStream.openXml({ version: "1.0", encoding: "UTF-8", standalone: "yes" });
+        xmlStream.leafNode(this.tag, attrs);
+    }
+    /**
+     * Generate XML string directly (convenience method)
+     * Uses render() internally to ensure consistency
+     */
+    toXml(model) {
+        const xmlStream = new xml_stream_1.XmlStream();
+        this.render(xmlStream, model);
+        return xmlStream.xml;
+    }
+    // Parsing not implemented - form controls are write-only for now
+    parseOpen() {
+        return true;
+    }
+    parseText() {
+        // Not implemented
+    }
+    parseClose() {
+        return false;
+    }
+}
+exports.CtrlPropXform = CtrlPropXform;

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/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);
     }