@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/{browser/modules/word/writers → esm/modules/word/writer}/run-writer.js

@@ -4,6 +4,7 @@
  * Renders w:rPr and run-level content (w:t, w:br, w:tab, w:drawing, etc.)
  */
 import { NS_A, NS_PIC, URI_PIC, NS_ASVG, GUID_SVG } from "../constants.js";
+import { DocxRawXmlPolicyError } from "../errors.js";
 /** Render a single border element. */
 export function renderBorderElement(xml, tagName, border) {
     const attrs = { "w:val": border.style };
@@ -34,6 +35,17 @@ export function renderBorderElement(xml, tagName, border) {
 /** Render w:rPr (run properties). Element order follows ECMA-376 CT_RPr schema. */
 export function renderRunProperties(xml, rPr, insidePropertyChange = false) {
     xml.openNode("w:rPr");
+    renderRunPropertiesContents(xml, rPr, insidePropertyChange);
+    xml.closeNode();
+}
+/**
+ * Render the **contents** of a w:rPr element (without the w:rPr wrapper).
+ *
+ * Use this when you need to inject additional siblings (like w:ins/w:del for
+ * paragraph mark revisions) into the same w:rPr element. Otherwise prefer
+ * {@link renderRunProperties} which manages the wrapper for you.
+ */
+export function renderRunPropertiesContents(xml, rPr, insidePropertyChange = false) {
     // 1. rStyle
     if (rPr.style) {
         xml.leafNode("w:rStyle", { "w:val": rPr.style });
@@ -243,7 +255,29 @@ export function renderRunProperties(xml, rPr, insidePropertyChange = false) {
         }
         xml.leafNode("w:lang", attrs);
     }
-    // 25. eastAsianLayout (not yet supported; placeholder)
+    // 25. eastAsianLayout (ECMA-376 §17.3.2.10)
+    if (rPr.eastAsianLayout) {
+        const ea = rPr.eastAsianLayout;
+        const attrs = {};
+        if (ea.id != null) {
+            attrs["w:id"] = String(ea.id);
+        }
+        if (ea.combine) {
+            attrs["w:combine"] = "1";
+        }
+        if (ea.combineBrackets) {
+            attrs["w:combineBrackets"] = ea.combineBrackets;
+        }
+        if (ea.vert) {
+            attrs["w:vert"] = "1";
+        }
+        if (ea.vertCompress) {
+            attrs["w:vertCompress"] = "1";
+        }
+        if (Object.keys(attrs).length > 0) {
+            xml.leafNode("w:eastAsianLayout", attrs);
+        }
+    }
     // 26. specVanish
     if (rPr.specVanish) {
         xml.leafNode("w:specVanish");
@@ -272,7 +306,6 @@ export function renderRunProperties(xml, rPr, insidePropertyChange = false) {
         }
         xml.closeNode();
     }
-    xml.closeNode();
 }
 /** Render w:shd element. */
 export function renderShading(xml, shd) {
@@ -283,9 +316,15 @@ export function renderShading(xml, shd) {
     });
 }
 /** Render an inline image (w:drawing > wp:inline). */
-function renderInlineImage(xml, img) {
+function renderInlineImage(xml, img, imageRemap) {
     const drawingId = img.drawingId ?? 1;
     const name = img.name ?? "Picture";
+    // Resolve the relationship id used in r:embed: prefer a packager-provided
+    // remap (used when the model rId clashed with an existing relationship in
+    // the same .rels file), otherwise emit the model rId verbatim. We never
+    // mutate the model itself.
+    const embedRId = imageRemap?.get(img.rId) ?? img.rId;
+    const svgEmbedRId = img.svgRId ? (imageRemap?.get(img.svgRId) ?? img.svgRId) : undefined;
     xml.openNode("w:drawing");
     xml.openNode("wp:inline", {
         distT: "0",
@@ -314,19 +353,19 @@ function renderInlineImage(xml, img) {
     // blipFill
     xml.openNode("pic:blipFill");
     if (img.svgRId) {
-        xml.openNode("a:blip", { "r:embed": img.rId });
+        xml.openNode("a:blip", { "r:embed": embedRId });
         xml.openNode("a:extLst");
         xml.openNode("a:ext", { uri: GUID_SVG });
         xml.leafNode("asvg:svgBlip", {
             "xmlns:asvg": NS_ASVG,
-            "r:embed": img.svgRId
+            "r:embed": svgEmbedRId
         });
         xml.closeNode(); // a:ext
         xml.closeNode(); // a:extLst
         xml.closeNode(); // a:blip
     }
     else {
-        xml.leafNode("a:blip", { "r:embed": img.rId });
+        xml.leafNode("a:blip", { "r:embed": embedRId });
     }
     // Source rectangle (crop)
     if (img.srcRect) {
@@ -455,10 +494,43 @@ function renderFfData(xml, ff) {
     }
     xml.closeNode(); // ffData
 }
-/** Render a field code (PAGE, NUMPAGES, etc.). */
-function renderField(xml, field) {
+/**
+ * Emit a UTF-8 text payload as one or more `<w:t>` elements separated by
+ * `<w:br/>` whenever the source contains a newline. OOXML's CT_Text
+ * forbids `\n` / `\r` inside its value — Word silently rejects packages
+ * that contain them. Used by both run text content and field cached
+ * values.
+ */
+function writeTextWithBreaks(xml, value) {
+    if (value.indexOf("\n") < 0 && value.indexOf("\r") < 0) {
+        xml.openNode("w:t", { "xml:space": "preserve" });
+        xml.writeText(value);
+        xml.closeNode();
+        return;
+    }
+    const segments = value.replace(/\r\n?/g, "\n").split("\n");
+    for (let i = 0; i < segments.length; i++) {
+        if (segments[i].length > 0) {
+            xml.openNode("w:t", { "xml:space": "preserve" });
+            xml.writeText(segments[i]);
+            xml.closeNode();
+        }
+        if (i < segments.length - 1) {
+            xml.leafNode("w:br");
+        }
+    }
+}
+/** Render a field code (PAGE, NUMPAGES, etc.). Inherits run properties from the containing run. */
+function renderField(xml, field, rPr) {
+    // Helper to emit inherited rPr in each field sub-run
+    const emitRPr = () => {
+        if (rPr) {
+            renderRunProperties(xml, rPr);
+        }
+    };
     // Begin
     xml.openNode("w:r");
+    emitRPr();
     if (field.formField) {
         xml.openNode("w:fldChar", { "w:fldCharType": "begin" });
         renderFfData(xml, field.formField);
@@ -470,34 +542,39 @@ function renderField(xml, field) {
     xml.closeNode();
     // Instruction
     xml.openNode("w:r");
+    emitRPr();
     xml.openNode("w:instrText", { "xml:space": "preserve" });
     xml.writeText(field.instruction);
     xml.closeNode();
     xml.closeNode();
     // Separate
     xml.openNode("w:r");
+    emitRPr();
     xml.leafNode("w:fldChar", { "w:fldCharType": "separate" });
     xml.closeNode();
     // Cached value
     if (field.cachedValue !== undefined) {
         xml.openNode("w:r");
-        xml.openNode("w:t");
-        xml.writeText(field.cachedValue);
-        xml.closeNode();
+        emitRPr();
+        writeTextWithBreaks(xml, field.cachedValue);
         xml.closeNode();
     }
     // End
     xml.openNode("w:r");
+    emitRPr();
     xml.leafNode("w:fldChar", { "w:fldCharType": "end" });
     xml.closeNode();
 }
 /** Render a single piece of run content. Returns true if rendered inside a w:r, false if it creates its own runs. */
-function renderRunContent(xml, content) {
+function renderRunContent(xml, content, helpers) {
     switch (content.type) {
         case "text":
-            xml.openNode("w:t", { "xml:space": "preserve" });
-            xml.writeText(content.text);
-            xml.closeNode();
+            // OOXML's <w:t> is a string with no embedded line breaks (the schema
+            // forbids U+000A / U+000D inside its text node). Authors writing
+            // multi-line cell labels conventionally pass `\n` in the source string;
+            // we split those into multiple <w:t> + <w:br/> pairs so Word renders a
+            // soft line break instead of rejecting the file.
+            writeTextWithBreaks(xml, content.text);
             return true;
         case "break":
             if (content.breakType) {
@@ -547,13 +624,13 @@ function renderRunContent(xml, content) {
             // Ruby text (w:rt)
             xml.openNode("w:rt");
             for (const run of content.rubyText) {
-                renderRun(xml, run);
+                renderRun(xml, run, helpers);
             }
             xml.closeNode();
             // Base text (w:rubyBase)
             xml.openNode("w:rubyBase");
             for (const run of content.baseText) {
-                renderRun(xml, run);
+                renderRun(xml, run, helpers);
             }
             xml.closeNode();
             xml.closeNode(); // w:ruby
@@ -579,7 +656,19 @@ function renderRunContent(xml, content) {
             return true;
         }
         case "image":
-            renderInlineImage(xml, content);
+            // Skip placeholder images (rId === ""). They originate from import
+            // pipelines like html-import that don't register the underlying
+            // ImageDef — emitting <w:drawing> with a missing r:embed produces a
+            // dangling reference Word rejects.
+            if (!content.rId) {
+                if (content.altText) {
+                    xml.openNode("w:t", { "xml:space": "preserve" });
+                    xml.writeText(content.altText);
+                    xml.closeNode();
+                }
+                return true;
+            }
+            renderInlineImage(xml, content, helpers?.imageRemap);
             return true;
         case "field":
             // Fields create their own runs — must be rendered outside the current run
@@ -602,12 +691,24 @@ function renderRunContent(xml, content) {
         case "dateField":
             // Rendered as a field instruction
             return false;
+        case "opaqueRun": {
+            // Honor the rawXmlPolicy from the active security policy.
+            const policy = helpers?.rawXmlPolicy;
+            if (policy === "reject") {
+                throw new DocxRawXmlPolicyError("opaqueRun");
+            }
+            if (policy !== "strip") {
+                // "preserve" (default) — write verbatim.
+                xml.writeRaw(content.rawXml);
+            }
+            return true;
+        }
         default:
             return true;
     }
 }
 /** Render a w:r element. */
-export function renderRun(xml, run) {
+export function renderRun(xml, run, helpers) {
     // Separate field content that needs its own runs
     const normalContent = [];
     const fieldContent = [];
@@ -616,13 +717,14 @@ export function renderRun(xml, run) {
             fieldContent.push(c);
         }
         else if (c.type === "dateField") {
-            // Convert date field to field instruction
+            // Convert date field to field instruction.
+            // Use the model's cachedValue if provided; otherwise leave empty (deterministic output).
             const fmt = c.format ?? "yyyy-MM-dd";
             const lang = c.language ?? "en-US";
             fieldContent.push({
                 type: "field",
                 instruction: ` DATE \\@ "${fmt}" \\l ${lang} `,
-                cachedValue: new Date().toISOString().split("T")[0]
+                cachedValue: c.cachedValue ?? ""
             });
         }
         else {
@@ -636,14 +738,14 @@ export function renderRun(xml, run) {
             renderRunProperties(xml, run.properties);
         }
         for (const content of normalContent) {
-            renderRunContent(xml, content);
+            renderRunContent(xml, content, helpers);
         }
         xml.closeNode();
     }
-    // Render field content (each field creates multiple runs)
+    // Render field content (each field creates multiple runs, inheriting this run's properties)
     for (const fc of fieldContent) {
         if (fc.type === "field") {
-            renderField(xml, fc);
+            renderField(xml, fc, run.properties);
         }
     }
 }

package/dist/esm/modules/word/writer/sdt-writer.js

@@ -0,0 +1,189 @@
+/**
+ * DOCX Writers - Structured Document Tag (SDT) Properties
+ *
+ * This file intentionally only renders `<w:sdtPr>` — the property block — so
+ * it has no dependency on the block-level renderers (paragraph/table/run/
+ * nested SDT). Callers are responsible for opening `<w:sdt>` and
+ * `<w:sdtContent>` themselves and for dispatching child blocks using their
+ * own render functions, which keeps the writer module graph acyclic.
+ */
+/**
+ * Render the `<w:sdt>` ↦ `<w:sdtPr>` block for a given SDT.
+ *
+ * Does not emit `<w:sdt>` itself nor `<w:sdtContent>` — that is the caller's
+ * responsibility. Designed so block-level renderers (table cell, header/
+ * footer, document body) can share the property emission logic without
+ * forming an import cycle through child-block dispatch.
+ *
+ * `ctx` may be undefined when called from a renderer that only owns a
+ * `RenderHelpers`. In that case we cannot draw an auto-id from the document
+ * id generator and will simply omit `<w:id>` if the model didn't supply one.
+ */
+export function renderSdtPr(xml, sdt, ctx) {
+    if (!sdt.properties) {
+        return;
+    }
+    xml.openNode("w:sdtPr");
+    const p = sdt.properties;
+    // Auto-assign ID if not provided (Word strongly expects unique IDs).
+    // When invoked without a ctx we skip the w:id when the model didn't
+    // supply one — emitting nothing is safer than reusing a colliding id.
+    const sdtId = p.id ?? ctx?.ids.nextSdtId();
+    if (sdtId !== undefined) {
+        xml.leafNode("w:id", { "w:val": String(sdtId) });
+    }
+    if (p.tag) {
+        xml.leafNode("w:tag", { "w:val": p.tag });
+    }
+    if (p.alias) {
+        xml.leafNode("w:alias", { "w:val": p.alias });
+    }
+    // Lock: combine lockContent + lockSdt
+    if (p.lockContent && p.lockSdt) {
+        xml.leafNode("w:lock", { "w:val": "sdtContentLocked" });
+    }
+    else if (p.lockContent) {
+        xml.leafNode("w:lock", { "w:val": "contentLocked" });
+    }
+    else if (p.lockSdt) {
+        xml.leafNode("w:lock", { "w:val": "sdtLocked" });
+    }
+    // Appearance (w15:appearance for modern SDTs)
+    if (p.appearance) {
+        xml.leafNode("w15:appearance", { "w15:val": p.appearance });
+    }
+    // Show placeholder toggle
+    if (p.showingPlaceholder) {
+        xml.leafNode("w:showingPlcHdr");
+    }
+    if (p.placeholder) {
+        xml.openNode("w:placeholder");
+        xml.leafNode("w:docPart", { "w:val": p.placeholder });
+        xml.closeNode();
+    }
+    if (p.temporary) {
+        xml.leafNode("w:temporary");
+    }
+    if (p.dataBinding) {
+        const bindAttrs = {
+            "w:xpath": p.dataBinding.xpath,
+            "w:storeItemID": p.dataBinding.storeItemId
+        };
+        if (p.dataBinding.prefixMappings) {
+            bindAttrs["w:prefixMappings"] = p.dataBinding.prefixMappings;
+        }
+        xml.leafNode("w:dataBinding", bindAttrs);
+    }
+    // Type discriminator markers
+    if (p.plainText) {
+        xml.leafNode("w:text");
+    }
+    if (p.richText) {
+        xml.leafNode("w:richText");
+    }
+    if (p.picture) {
+        xml.leafNode("w:picture");
+    }
+    if (p.group) {
+        xml.leafNode("w:group");
+    }
+    if (p.equation) {
+        xml.leafNode("w:equation");
+    }
+    if (p.citation) {
+        xml.leafNode("w:citation");
+    }
+    if (p.bibliography) {
+        xml.leafNode("w:bibliography");
+    }
+    if (p.repeatingSectionItem) {
+        xml.leafNode("w15:repeatingSectionItem");
+    }
+    if (p.repeatingSection) {
+        // w15:repeatingSection has child elements (not attributes) per the schema
+        const rs = p.repeatingSection;
+        const hasChildren = rs.sectionTitle !== undefined || rs.allowInsertDelete !== undefined;
+        if (hasChildren) {
+            xml.openNode("w15:repeatingSection");
+            if (rs.sectionTitle !== undefined) {
+                xml.leafNode("w15:sectionTitle", { "w15:val": rs.sectionTitle });
+            }
+            if (rs.allowInsertDelete === false) {
+                xml.leafNode("w15:doNotAllowInsertDeleteSection");
+            }
+            xml.closeNode();
+        }
+        else {
+            xml.leafNode("w15:repeatingSection");
+        }
+    }
+    // Checkbox (w14 extension)
+    if (p.checkbox) {
+        xml.openNode("w14:checkbox");
+        xml.leafNode("w14:checked", p.checkbox.checked ? { "w14:val": "1" } : { "w14:val": "0" });
+        if (p.checkbox.checkedChar || p.checkbox.checkedFont) {
+            const cAttrs = {};
+            if (p.checkbox.checkedChar) {
+                cAttrs["w14:val"] = p.checkbox.checkedChar;
+            }
+            if (p.checkbox.checkedFont) {
+                cAttrs["w14:font"] = p.checkbox.checkedFont;
+            }
+            xml.leafNode("w14:checkedState", cAttrs);
+        }
+        if (p.checkbox.uncheckedChar || p.checkbox.uncheckedFont) {
+            const uAttrs = {};
+            if (p.checkbox.uncheckedChar) {
+                uAttrs["w14:val"] = p.checkbox.uncheckedChar;
+            }
+            if (p.checkbox.uncheckedFont) {
+                uAttrs["w14:font"] = p.checkbox.uncheckedFont;
+            }
+            xml.leafNode("w14:uncheckedState", uAttrs);
+        }
+        xml.closeNode();
+    }
+    // Dropdown list
+    if (p.dropdownList) {
+        xml.openNode("w:dropDownList");
+        for (const item of p.dropdownList) {
+            const attrs = { "w:value": item.value };
+            if (item.displayText) {
+                attrs["w:displayText"] = item.displayText;
+            }
+            xml.leafNode("w:listItem", attrs);
+        }
+        xml.closeNode();
+    }
+    // ComboBox
+    if (p.comboBox) {
+        xml.openNode("w:comboBox");
+        for (const item of p.comboBox) {
+            const attrs = { "w:value": item.value };
+            if (item.displayText) {
+                attrs["w:displayText"] = item.displayText;
+            }
+            xml.leafNode("w:listItem", attrs);
+        }
+        xml.closeNode();
+    }
+    // Date picker
+    if (p.date) {
+        const dateAttrs = {};
+        if (p.date.fullDate) {
+            dateAttrs["w:fullDate"] = p.date.fullDate;
+        }
+        xml.openNode("w:date", Object.keys(dateAttrs).length > 0 ? dateAttrs : undefined);
+        if (p.date.dateFormat) {
+            xml.leafNode("w:dateFormat", { "w:val": p.date.dateFormat });
+        }
+        if (p.date.lid) {
+            xml.leafNode("w:lid", { "w:val": p.date.lid });
+        }
+        if (p.date.storeMappedDataAs) {
+            xml.leafNode("w:storeMappedDataAs", { "w:val": p.date.storeMappedDataAs });
+        }
+        xml.closeNode();
+    }
+    xml.closeNode(); // w:sdtPr
+}

package/dist/esm/modules/word/writer/stream-buf.js

@@ -0,0 +1,73 @@
+/**
+ * StreamBuf - Minimal Event-Driven Stream Buffer for DOCX Streaming
+ *
+ * A lightweight stream buffer that emits data events when written to.
+ * This is specifically designed for the streaming DOCX writer's needs:
+ * - Write StringBuf or Uint8Array data
+ * - Emit "data" events with Uint8Array chunks
+ * - Emit "finish" on end()
+ * - Support custom event listeners (once/on/emit)
+ *
+ * This is a word-module-local implementation to avoid depending on @excel/utils.
+ */
+import { EventEmitter } from "../../../utils/event-emitter.js";
+/**
+ * Minimal streaming buffer for piping XML data to ZIP compression.
+ * Extends EventEmitter for event-driven data flow.
+ */
+class StreamBuf extends EventEmitter {
+    constructor(_options) {
+        super();
+        this._ended = false;
+    }
+    /** Returns true if the stream is writable (not ended). */
+    get writable() {
+        return !this._ended;
+    }
+    /**
+     * Write data to the stream. Emits a "data" event with the bytes.
+     */
+    write(data, _encoding, callback) {
+        let bytes;
+        if (data instanceof Uint8Array) {
+            bytes = data;
+        }
+        else if (typeof data === "string") {
+            bytes = new TextEncoder().encode(data);
+        }
+        else if (ArrayBuffer.isView(data)) {
+            bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer) {
+            bytes = new Uint8Array(data);
+        }
+        else if (data && typeof data.toBuffer === "function") {
+            // StringBuf-like object
+            bytes = data.toBuffer();
+        }
+        else {
+            bytes = new Uint8Array(0);
+        }
+        if (bytes.length > 0) {
+            this.emit("data", bytes);
+        }
+        if (callback) {
+            callback();
+        }
+    }
+    /**
+     * End the stream. Emits "finish" event.
+     */
+    end(chunk, _encoding, callback) {
+        if (chunk) {
+            this.write(chunk);
+        }
+        this._ended = true;
+        this.emit("finish");
+        this.emit("close");
+        if (callback) {
+            callback();
+        }
+    }
+}
+export { StreamBuf };