@cj-tech-master/excelts 9.0.0 → 9.1.0

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

@@ -8,6 +8,8 @@ const form_control_1 = require("../../../form-control.js");
 class VmlDrawingXform extends base_xform_1.BaseXform {
     constructor() {
         super();
+        // Internal state for parsing header image shapes
+        this._parsingHeaderImage = false;
         this.map = {
             "v:shape": new vml_shape_xform_1.VmlShapeXform()
         };
@@ -23,8 +25,10 @@ class VmlDrawingXform extends base_xform_1.BaseXform {
         const renderModel = (model || this.model);
         const comments = renderModel.comments;
         const formControls = renderModel.formControls;
+        const headerImage = renderModel.headerImage;
         const hasComments = comments && comments.length > 0;
         const hasFormControls = formControls && formControls.length > 0;
+        const hasHeaderImage = !!headerImage;
         xmlStream.openXml(writer_1.StdDocAttributes);
         xmlStream.openNode(this.tag, VmlDrawingXform.DRAWING_ATTRIBUTES);
         // Shape layout - shared by both notes and form controls
@@ -62,6 +66,40 @@ class VmlDrawingXform extends base_xform_1.BaseXform {
             xmlStream.leafNode("o:lock", { "v:ext": "edit", shapetype: "t" });
             xmlStream.closeNode();
         }
+        // Shapetype 75 for header/footer image (watermark)
+        if (hasHeaderImage) {
+            xmlStream.openNode("v:shapetype", {
+                id: "_x0000_t75",
+                coordsize: "21600,21600",
+                "o:spt": "75",
+                "o:preferrelative": "t",
+                path: "m@4@5l@4@11@9@11@9@5xe",
+                filled: "f",
+                stroked: "f"
+            });
+            xmlStream.leafNode("v:stroke", { joinstyle: "miter" });
+            xmlStream.openNode("v:formulas");
+            xmlStream.leafNode("v:f", { eqn: "if lineDrawn pixelLineWidth 0" });
+            xmlStream.leafNode("v:f", { eqn: "sum @0 1 0" });
+            xmlStream.leafNode("v:f", { eqn: "sum 0 0 @1" });
+            xmlStream.leafNode("v:f", { eqn: "prod @2 1 2" });
+            xmlStream.leafNode("v:f", { eqn: "prod @3 21600 pixelWidth" });
+            xmlStream.leafNode("v:f", { eqn: "prod @3 21600 pixelHeight" });
+            xmlStream.leafNode("v:f", { eqn: "sum @0 0 1" });
+            xmlStream.leafNode("v:f", { eqn: "prod @6 1 2" });
+            xmlStream.leafNode("v:f", { eqn: "prod @7 21600 pixelWidth" });
+            xmlStream.leafNode("v:f", { eqn: "sum @8 21600 0" });
+            xmlStream.leafNode("v:f", { eqn: "prod @7 21600 pixelHeight" });
+            xmlStream.leafNode("v:f", { eqn: "sum @10 21600 0" });
+            xmlStream.closeNode(); // v:formulas
+            xmlStream.leafNode("v:path", {
+                "o:extrusionok": "f",
+                gradientshapeok: "t",
+                "o:connecttype": "rect"
+            });
+            xmlStream.leafNode("o:lock", { "v:ext": "edit", aspectratio: "t" });
+            xmlStream.closeNode(); // v:shapetype
+        }
         // Render comment shapes
         if (hasComments) {
             for (let i = 0; i < comments.length; i++) {
@@ -74,8 +112,32 @@ class VmlDrawingXform extends base_xform_1.BaseXform {
                 this._renderCheckboxShape(xmlStream, control);
             }
         }
+        // Render header/footer image shape
+        if (hasHeaderImage) {
+            this._renderHeaderImageShape(xmlStream, headerImage);
+        }
         xmlStream.closeNode();
     }
+    /**
+     * Render a header/footer image shape for watermark
+     */
+    _renderHeaderImageShape(xmlStream, headerImage) {
+        const width = headerImage.width ?? 467.25;
+        const height = headerImage.height ?? 311.25;
+        // CH = Center Header, used by Excel for center-positioned header images
+        xmlStream.openNode("v:shape", {
+            id: "CH",
+            "o:spid": "_x0000_s2049",
+            type: "#_x0000_t75",
+            style: `position:absolute;margin-left:0;margin-top:0;width:${width}pt;height:${height}pt;z-index:1`
+        });
+        xmlStream.leafNode("v:imagedata", {
+            "o:relid": headerImage.imageRelId,
+            "o:title": "watermark"
+        });
+        xmlStream.leafNode("o:lock", { "v:ext": "edit", rotation: "t" });
+        xmlStream.closeNode(); // v:shape
+    }
     /**
      * Render a checkbox form control shape
      */
@@ -144,7 +206,7 @@ class VmlDrawingXform extends base_xform_1.BaseXform {
         xmlStream.closeNode(); // x:ClientData
         xmlStream.closeNode(); // v:shape
     }
-    // Parsing - delegate to VmlShapeXform for notes
+    // Parsing - delegate to VmlShapeXform for notes, handle header images directly
     parseOpen(node) {
         if (this.parser) {
             this.parser.parseOpen(node);
@@ -158,10 +220,34 @@ class VmlDrawingXform extends base_xform_1.BaseXform {
                     formControls: []
                 };
                 break;
+            case "v:shape":
+                // Check if this is a header image shape (type="#_x0000_t75")
+                if (node.attributes.type === "#_x0000_t75") {
+                    this._parsingHeaderImage = true;
+                    // Extract width/height from style
+                    const style = node.attributes.style || "";
+                    const widthMatch = /width:([0-9.]+)pt/.exec(style);
+                    const heightMatch = /height:([0-9.]+)pt/.exec(style);
+                    this._headerImageWidth = widthMatch ? parseFloat(widthMatch[1]) : undefined;
+                    this._headerImageHeight = heightMatch ? parseFloat(heightMatch[1]) : undefined;
+                }
+                else {
+                    // Regular shape — delegate to VmlShapeXform (comments)
+                    this.parser = this.map[node.name];
+                    if (this.parser) {
+                        this.parser.parseOpen(node);
+                    }
+                }
+                break;
             default:
-                this.parser = this.map[node.name];
-                if (this.parser) {
-                    this.parser.parseOpen(node);
+                if (this._parsingHeaderImage && node.name === "v:imagedata") {
+                    this._headerImageRelId = node.attributes["o:relid"];
+                }
+                else {
+                    this.parser = this.map[node.name];
+                    if (this.parser) {
+                        this.parser.parseOpen(node);
+                    }
                 }
                 break;
         }
@@ -181,6 +267,19 @@ class VmlDrawingXform extends base_xform_1.BaseXform {
             return true;
         }
         switch (name) {
+            case "v:shape":
+                if (this._parsingHeaderImage && this._headerImageRelId) {
+                    this.model.headerImage = {
+                        imageRelId: this._headerImageRelId,
+                        width: this._headerImageWidth,
+                        height: this._headerImageHeight
+                    };
+                }
+                this._parsingHeaderImage = false;
+                this._headerImageRelId = undefined;
+                this._headerImageWidth = undefined;
+                this._headerImageHeight = undefined;
+                return true;
             case this.tag:
                 return false;
             default:

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

@@ -235,6 +235,8 @@ class WorkSheetXform extends base_xform_1.BaseXform {
         // Process background and image media entries
         const backgroundMedia = [];
         const imageMedia = [];
+        const watermarkMedia = [];
+        const headerImageMedia = [];
         model.media.forEach(medium => {
             if (medium.type === "background") {
                 backgroundMedia.push(medium);
@@ -242,6 +244,12 @@ class WorkSheetXform extends base_xform_1.BaseXform {
             else if (medium.type === "image") {
                 imageMedia.push(medium);
             }
+            else if (medium.type === "watermark") {
+                watermarkMedia.push(medium);
+            }
+            else if (medium.type === "headerImage") {
+                headerImageMedia.push(medium);
+            }
         });
         // Handle background images
         backgroundMedia.forEach(medium => {
@@ -279,6 +287,107 @@ class WorkSheetXform extends base_xform_1.BaseXform {
             drawing.anchors.push(...result.anchors);
             drawing.rels = result.rels;
         }
+        // Handle watermark overlay images — placed as a full-sheet drawing with transparency
+        if (watermarkMedia.length > 0) {
+            let { drawing } = model;
+            if (!drawing) {
+                drawing = model.drawing = {
+                    rId: nextRid(rels),
+                    name: `drawing${++options.drawingsCount}`,
+                    anchors: [],
+                    rels: []
+                };
+                options.drawings.push(drawing);
+                rels.push({
+                    Id: drawing.rId,
+                    Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+                    Target: (0, ooxml_paths_1.drawingRelTargetFromWorksheet)(drawing.name)
+                });
+            }
+            for (const medium of watermarkMedia) {
+                const bookImage = options.media[medium.imageId];
+                if (!bookImage) {
+                    continue;
+                }
+                const rIdImage = nextRid(drawing.rels);
+                drawing.rels.push({
+                    Id: rIdImage,
+                    Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+                    Target: (0, drawing_utils_1.resolveMediaTarget)(bookImage)
+                });
+                // Convert opacity (0-1) to OOXML percentage (0-100000), clamped
+                const rawOpacity = medium.opacity !== undefined ? medium.opacity : 0.15;
+                const clampedOpacity = Math.max(0, Math.min(1, rawOpacity));
+                const alphaModFix = Math.round(clampedOpacity * 100000);
+                // Compute coverage based on actual worksheet dimensions.
+                // Use the model's dimensions if available, otherwise use generous defaults.
+                const dims = model.dimensions;
+                const maxCol = dims ? Math.max(dims.model?.right ?? 100, 100) : 100;
+                const maxRow = dims ? Math.max(dims.model?.bottom ?? 200, 200) : 200;
+                drawing.anchors.push({
+                    picture: {
+                        rId: rIdImage,
+                        alphaModFix
+                    },
+                    // Cover the full data area with extra margin
+                    range: {
+                        editAs: "absolute",
+                        tl: { nativeCol: 0, nativeColOff: 0, nativeRow: 0, nativeRowOff: 0 },
+                        br: { nativeCol: maxCol, nativeColOff: 0, nativeRow: maxRow, nativeRowOff: 0 }
+                    }
+                });
+            }
+        }
+        // Handle header watermark images — VML header/footer image
+        if (headerImageMedia.length > 0) {
+            const medium = headerImageMedia[0]; // Only one header image per sheet
+            const bookImage = options.media[medium.imageId];
+            if (bookImage) {
+                const rIdVml = nextRid(rels);
+                rels.push({
+                    Id: rIdVml,
+                    Type: rel_type_1.RelType.VmlDrawing,
+                    Target: (0, ooxml_paths_1.vmlDrawingHFRelTargetFromWorksheet)(fileIndex)
+                });
+                // Store header image info on the model for the VML writer and worksheet render
+                model.headerImage = {
+                    vmlRelId: rIdVml,
+                    imageId: medium.imageId,
+                    bookImage,
+                    headerWidth: medium.headerWidth,
+                    headerHeight: medium.headerHeight
+                };
+                // Flag for content-types registration
+                options.hasHeaderWatermark = true;
+                // Update headerFooter to include &G placeholder.
+                // Respects the applyTo option: "all" (default), "odd", "even", "first".
+                if (!model.headerFooter) {
+                    model.headerFooter = {};
+                }
+                const applyTo = medium.applyTo || "all";
+                const insertG = (field) => {
+                    const existing = model.headerFooter[field] || "";
+                    if (existing.includes("&G")) {
+                        return existing;
+                    }
+                    if (existing.includes("&C")) {
+                        return existing.replace("&C", "&C&G");
+                    }
+                    return existing + "&C&G";
+                };
+                if (applyTo === "all" || applyTo === "odd") {
+                    model.headerFooter.oddHeader = insertG("oddHeader");
+                }
+                if (applyTo === "all" || applyTo === "even") {
+                    model.headerFooter.evenHeader = insertG("evenHeader");
+                    model.headerFooter.differentOddEven = true;
+                }
+                if (applyTo === "all" || applyTo === "first") {
+                    model.headerFooter.firstHeader = insertG("firstHeader");
+                    model.headerFooter.differentFirst = true;
+                }
+            }
+        }
         // prepare tables
         model.tables.forEach(table => {
             // relationships
@@ -439,10 +548,18 @@ class WorkSheetXform extends base_xform_1.BaseXform {
             // NOTE: Excel is picky about worksheet child element order; legacyDrawing must come before controls.
             model.rels.forEach(rel => {
                 if (rel.Type === rel_type_1.RelType.VmlDrawing) {
+                    // Skip VML rels that are for header images (they use legacyDrawingHF instead)
+                    if (model.headerImage && rel.Id === model.headerImage.vmlRelId) {
+                        return;
+                    }
                     xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
                 }
             });
         }
+        // legacyDrawingHF — VML drawing for header/footer images (watermark in header mode)
+        if (model.headerImage) {
+            xmlStream.leafNode("legacyDrawingHF", { "r:id": model.headerImage.vmlRelId });
+        }
         // Controls section for legacy form controls (checkboxes, etc.)
         // Excel expects <controls> entries that reference ctrlProp relationships.
         if (model.formControls && model.formControls.length > 0) {
@@ -658,13 +775,23 @@ class WorkSheetXform extends base_xform_1.BaseXform {
                         // Also extract images to model.media for backward compatibility
                         drawing.anchors.forEach(anchor => {
                             if (anchor.medium) {
-                                const image = {
-                                    type: "image",
-                                    imageId: anchor.medium.index,
-                                    range: anchor.range,
-                                    hyperlinks: anchor.picture.hyperlinks
-                                };
-                                model.media.push(image);
+                                // Detect overlay watermarks: drawings that carry alphaModFix
+                                const hasAlpha = anchor.medium.alphaModFix !== undefined && anchor.medium.alphaModFix < 100000;
+                                if (hasAlpha) {
+                                    model.media.push({
+                                        type: "watermark",
+                                        imageId: anchor.medium.index,
+                                        opacity: anchor.medium.alphaModFix / 100000
+                                    });
+                                }
+                                else {
+                                    model.media.push({
+                                        type: "image",
+                                        imageId: anchor.medium.index,
+                                        range: anchor.range,
+                                        hyperlinks: anchor.picture.hyperlinks
+                                    });
+                                }
                             }
                         });
                     }

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

@@ -909,6 +909,17 @@ class XLSX {
         const vmlDrawing = await xform.parseStream(entry);
         model.vmlDrawings[(0, ooxml_paths_1.vmlDrawingRelTargetFromWorksheetName)(name)] = vmlDrawing;
     }
+    async _processVmlDrawingHFEntry(entry, model, _name) {
+        const xform = new vml_drawing_xform_1.VmlDrawingXform();
+        const vmlDrawing = await xform.parseStream(entry);
+        // Store parsed header image info for reconciliation
+        if (vmlDrawing && vmlDrawing.headerImage) {
+            if (!model.vmlDrawingHF) {
+                model.vmlDrawingHF = {};
+            }
+            model.vmlDrawingHF[_name] = vmlDrawing.headerImage;
+        }
+    }
     async _processThemeEntry(stream, model, name) {
         await new Promise((resolve, reject) => {
             const streamBuf = this.createStreamBuf();
@@ -1023,6 +1034,13 @@ class XLSX {
             await this._processVmlDrawingEntry(stream, model, vmlDrawingName);
             return true;
         }
+        // VML header/footer drawings (watermark in header mode).
+        // Parse to extract header image info for round-trip preservation.
+        const vmlHFName = (0, ooxml_paths_1.getVmlDrawingHFNameFromPath)(entryName);
+        if (vmlHFName) {
+            await this._processVmlDrawingHFEntry(stream, model, vmlHFName);
+            return true;
+        }
         const commentsIndex = (0, ooxml_paths_1.getCommentsIndexFromPath)(entryName);
         if (commentsIndex) {
             await this._processCommentEntry(stream, model, `comments${commentsIndex}`);
@@ -1229,6 +1247,35 @@ class XLSX {
                     formControls: hasFormControls ? worksheet.formControls : []
                 });
             }
+            // Generate VML drawing for header/footer images (watermark in header mode)
+            if (worksheet.headerImage) {
+                const hdrImage = worksheet.headerImage;
+                const bookImage = hdrImage.bookImage;
+                const imageFileName = bookImage.name &&
+                    bookImage.extension &&
+                    bookImage.name.endsWith(`.${bookImage.extension}`)
+                    ? bookImage.name
+                    : `${bookImage.name}.${bookImage.extension}`;
+                const imageRelTarget = `../media/${imageFileName}`;
+                // Write the VML file for the header image
+                await this._renderToZip(zip, (0, ooxml_paths_1.vmlDrawingHFPath)(fileIndex), vmlDrawingXform, {
+                    comments: [],
+                    formControls: [],
+                    headerImage: {
+                        imageRelId: "rId1",
+                        width: hdrImage.headerWidth,
+                        height: hdrImage.headerHeight
+                    }
+                });
+                // Write the VML rels file referencing the image
+                await this._renderToZip(zip, (0, ooxml_paths_1.vmlDrawingHFRelsPath)(fileIndex), relationshipsXform, [
+                    {
+                        Id: "rId1",
+                        Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+                        Target: imageRelTarget
+                    }
+                ]);
+            }
             // Generate ctrlProp files for form controls
             if (hasFormControls) {
                 for (const control of worksheet.formControls) {
@@ -1375,6 +1422,7 @@ class XLSX {
         worksheetOptions.drawings = model.drawings = [];
         worksheetOptions.commentRefs = model.commentRefs = [];
         worksheetOptions.formControlRefs = model.formControlRefs = [];
+        model.hasHeaderWatermark = false;
         let tableCount = 0;
         model.tables = [];
         model.worksheets.forEach((worksheet, index) => {
@@ -1393,6 +1441,10 @@ class XLSX {
         });
         // ContentTypesXform expects this flag
         model.hasCheckboxes = model.styles.hasCheckboxes;
+        // Propagate header watermark flag from worksheet prepare options
+        if (worksheetOptions.hasHeaderWatermark) {
+            model.hasHeaderWatermark = true;
+        }
         // Build passthroughContentTypes for ContentTypesXform using PassthroughManager
         const passthrough = model.passthrough || {};
         const passthroughManager = new passthrough_manager_1.PassthroughManager();

package/dist/cjs/modules/pdf/core/pdf-writer.js

@@ -132,11 +132,12 @@ class PdfWriter {
     addPage(options) {
         const objNum = this.allocObject();
         const mediaBox = `[0 0 ${(0, pdf_object_1.pdfNumber)(options.width)} ${(0, pdf_object_1.pdfNumber)(options.height)}]`;
+        const contentsValue = typeof options.contentsRef === "string" ? options.contentsRef : (0, pdf_object_1.pdfRef)(options.contentsRef);
         const dict = new pdf_object_1.PdfDict()
             .set("Type", "/Page")
             .set("Parent", (0, pdf_object_1.pdfRef)(options.parentRef))
             .set("MediaBox", mediaBox)
-            .set("Contents", (0, pdf_object_1.pdfRef)(options.contentsRef))
+            .set("Contents", contentsValue)
             .set("Resources", (0, pdf_object_1.pdfRef)(options.resourcesRef));
         if (options.annotRefs && options.annotRefs.length > 0) {
             dict.set("Annots", "[" + options.annotRefs.map(r => (0, pdf_object_1.pdfRef)(r)).join(" ") + "]");