@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/esm/modules/word/writers/paragraph-writer.js

@@ -0,0 +1,516 @@
+/**
+ * DOCX Writers - Paragraph Properties & Paragraph
+ *
+ * Renders w:pPr and w:p elements including numbering, tabs, borders, etc.
+ */
+import { renderRunProperties, renderShading, renderRun, renderBorderElement } from "./run-writer.js";
+import { renderSectionProperties } from "./section-writer.js";
+/** Render a single border element. */
+export function renderBorder(xml, tagName, border) {
+    renderBorderElement(xml, tagName, border);
+}
+/** Render paragraph borders. */
+function renderParagraphBorders(xml, borders) {
+    xml.openNode("w:pBdr");
+    if (borders.top) {
+        renderBorder(xml, "w:top", borders.top);
+    }
+    if (borders.left) {
+        renderBorder(xml, "w:left", borders.left);
+    }
+    if (borders.bottom) {
+        renderBorder(xml, "w:bottom", borders.bottom);
+    }
+    if (borders.right) {
+        renderBorder(xml, "w:right", borders.right);
+    }
+    if (borders.between) {
+        renderBorder(xml, "w:between", borders.between);
+    }
+    if (borders.bar) {
+        renderBorder(xml, "w:bar", borders.bar);
+    }
+    xml.closeNode();
+}
+/** Render tab stops. */
+function renderTabs(xml, tabs) {
+    xml.openNode("w:tabs");
+    for (const tab of tabs) {
+        const attrs = {
+            "w:val": tab.type,
+            "w:pos": String(tab.position)
+        };
+        if (tab.leader) {
+            attrs["w:leader"] = tab.leader;
+        }
+        xml.leafNode("w:tab", attrs);
+    }
+    xml.closeNode();
+}
+/** Render paragraph frame properties (w:framePr). */
+function renderFrame(xml, frame) {
+    const attrs = {};
+    if (frame.dropCap) {
+        attrs["w:dropCap"] = frame.dropCap;
+    }
+    if (frame.lines !== undefined) {
+        attrs["w:lines"] = String(frame.lines);
+    }
+    if (frame.width !== undefined) {
+        attrs["w:w"] = String(frame.width);
+    }
+    if (frame.height !== undefined) {
+        attrs["w:h"] = String(frame.height);
+    }
+    if (frame.hSpace !== undefined) {
+        attrs["w:hSpace"] = String(frame.hSpace);
+    }
+    if (frame.vSpace !== undefined) {
+        attrs["w:vSpace"] = String(frame.vSpace);
+    }
+    if (frame.wrap) {
+        attrs["w:wrap"] = frame.wrap;
+    }
+    if (frame.hAnchor) {
+        attrs["w:hAnchor"] = frame.hAnchor;
+    }
+    if (frame.vAnchor) {
+        attrs["w:vAnchor"] = frame.vAnchor;
+    }
+    if (frame.x !== undefined) {
+        attrs["w:x"] = String(frame.x);
+    }
+    if (frame.xAlign) {
+        attrs["w:xAlign"] = frame.xAlign;
+    }
+    if (frame.y !== undefined) {
+        attrs["w:y"] = String(frame.y);
+    }
+    if (frame.yAlign) {
+        attrs["w:yAlign"] = frame.yAlign;
+    }
+    xml.leafNode("w:framePr", attrs);
+}
+/** Render w:pPr (paragraph properties). */
+export function renderParagraphProperties(xml, pPr, insidePropertyChange = false) {
+    xml.openNode("w:pPr");
+    if (pPr.style) {
+        xml.leafNode("w:pStyle", { "w:val": pPr.style });
+    }
+    if (pPr.keepNext) {
+        xml.leafNode("w:keepNext");
+    }
+    if (pPr.keepLines) {
+        xml.leafNode("w:keepLines");
+    }
+    if (pPr.pageBreakBefore) {
+        xml.leafNode("w:pageBreakBefore");
+    }
+    // Frame
+    if (pPr.frame) {
+        renderFrame(xml, pPr.frame);
+    }
+    if (pPr.widowControl !== undefined) {
+        xml.leafNode("w:widowControl", !pPr.widowControl ? { "w:val": "0" } : undefined);
+    }
+    if (pPr.suppressLineNumbers) {
+        xml.leafNode("w:suppressLineNumbers");
+    }
+    if (pPr.borders) {
+        renderParagraphBorders(xml, pPr.borders);
+    }
+    if (pPr.shading) {
+        renderShading(xml, pPr.shading);
+    }
+    if (pPr.suppressAutoHyphens) {
+        xml.leafNode("w:suppressAutoHyphens");
+    }
+    if (pPr.tabs && pPr.tabs.length > 0) {
+        renderTabs(xml, pPr.tabs);
+    }
+    if (pPr.spacing) {
+        const attrs = {};
+        if (pPr.spacing.before !== undefined) {
+            attrs["w:before"] = String(pPr.spacing.before);
+        }
+        if (pPr.spacing.after !== undefined) {
+            attrs["w:after"] = String(pPr.spacing.after);
+        }
+        if (pPr.spacing.line !== undefined) {
+            attrs["w:line"] = String(pPr.spacing.line);
+        }
+        if (pPr.spacing.lineRule) {
+            attrs["w:lineRule"] = pPr.spacing.lineRule;
+        }
+        if (pPr.spacing.beforeAutoSpacing) {
+            attrs["w:beforeAutospacing"] = "1";
+        }
+        if (pPr.spacing.afterAutoSpacing) {
+            attrs["w:afterAutospacing"] = "1";
+        }
+        xml.leafNode("w:spacing", attrs);
+    }
+    if (pPr.indent) {
+        const attrs = {};
+        if (pPr.indent.left !== undefined) {
+            attrs["w:left"] = String(pPr.indent.left);
+        }
+        if (pPr.indent.right !== undefined) {
+            attrs["w:right"] = String(pPr.indent.right);
+        }
+        if (pPr.indent.hanging !== undefined) {
+            attrs["w:hanging"] = String(pPr.indent.hanging);
+        }
+        if (pPr.indent.firstLine !== undefined) {
+            attrs["w:firstLine"] = String(pPr.indent.firstLine);
+        }
+        if (pPr.indent.start !== undefined) {
+            attrs["w:start"] = String(pPr.indent.start);
+        }
+        if (pPr.indent.end !== undefined) {
+            attrs["w:end"] = String(pPr.indent.end);
+        }
+        xml.leafNode("w:ind", attrs);
+    }
+    if (pPr.contextualSpacing) {
+        xml.leafNode("w:contextualSpacing");
+    }
+    if (pPr.mirrorIndents) {
+        xml.leafNode("w:mirrorIndents");
+    }
+    if (pPr.alignment) {
+        xml.leafNode("w:jc", { "w:val": pPr.alignment });
+    }
+    if (pPr.textAlignment) {
+        xml.leafNode("w:textAlignment", { "w:val": pPr.textAlignment });
+    }
+    if (pPr.outlineLevel !== undefined) {
+        xml.leafNode("w:outlineLvl", { "w:val": String(pPr.outlineLevel) });
+    }
+    if (pPr.numbering) {
+        xml.openNode("w:numPr");
+        xml.leafNode("w:ilvl", { "w:val": String(pPr.numbering.level ?? 0) });
+        xml.leafNode("w:numId", { "w:val": String(pPr.numbering.numId) });
+        xml.closeNode();
+    }
+    if (pPr.bidi) {
+        xml.leafNode("w:bidi");
+    }
+    if (pPr.wordWrap !== undefined) {
+        xml.leafNode("w:wordWrap", !pPr.wordWrap ? { "w:val": "0" } : undefined);
+    }
+    if (pPr.overflowPunctuation !== undefined) {
+        xml.leafNode("w:overflowPunct", !pPr.overflowPunctuation ? { "w:val": "0" } : undefined);
+    }
+    if (pPr.topLinePunctuation !== undefined) {
+        xml.leafNode("w:topLinePunct", !pPr.topLinePunctuation ? { "w:val": "0" } : undefined);
+    }
+    if (pPr.kinsoku !== undefined) {
+        xml.leafNode("w:kinsoku", !pPr.kinsoku ? { "w:val": "0" } : undefined);
+    }
+    if (pPr.autoSpaceEastAsianText !== undefined) {
+        xml.leafNode("w:autoSpaceDE", !pPr.autoSpaceEastAsianText ? { "w:val": "0" } : undefined);
+    }
+    if (pPr.autoSpaceEastAsianDigit !== undefined) {
+        xml.leafNode("w:autoSpaceDN", !pPr.autoSpaceEastAsianDigit ? { "w:val": "0" } : undefined);
+    }
+    if (pPr.snapToGrid !== undefined) {
+        xml.leafNode("w:snapToGrid", !pPr.snapToGrid ? { "w:val": "0" } : undefined);
+    }
+    if (pPr.textDirection) {
+        xml.leafNode("w:textDirection", { "w:val": pPr.textDirection });
+    }
+    if (pPr.thematicBreak) {
+        // Thematic break is rendered as a bottom border
+        xml.openNode("w:pBdr");
+        xml.leafNode("w:bottom", {
+            "w:val": "single",
+            "w:sz": "6",
+            "w:space": "1",
+            "w:color": "auto"
+        });
+        xml.closeNode();
+    }
+    if (pPr.sectionProperties) {
+        renderSectionProperties(xml, pPr.sectionProperties);
+    }
+    // Conditional formatting style mask (must come before rPr per schema)
+    if (pPr.cnfStyle) {
+        xml.leafNode("w:cnfStyle", { "w:val": pPr.cnfStyle });
+    }
+    // Paragraph mark insertion/deletion (track changes)
+    // These go inside a w:rPr wrapper within w:pPr
+    if (pPr.paragraphInsertion || pPr.paragraphDeletion) {
+        xml.openNode("w:rPr");
+        if (pPr.paragraphInsertion) {
+            const insAttrs = {
+                "w:id": String(pPr.paragraphInsertion.id),
+                "w:author": pPr.paragraphInsertion.author
+            };
+            if (pPr.paragraphInsertion.date) {
+                insAttrs["w:date"] = pPr.paragraphInsertion.date;
+            }
+            xml.leafNode("w:ins", insAttrs);
+        }
+        if (pPr.paragraphDeletion) {
+            const delAttrs = {
+                "w:id": String(pPr.paragraphDeletion.id),
+                "w:author": pPr.paragraphDeletion.author
+            };
+            if (pPr.paragraphDeletion.date) {
+                delAttrs["w:date"] = pPr.paragraphDeletion.date;
+            }
+            xml.leafNode("w:del", delAttrs);
+        }
+        xml.closeNode(); // w:rPr
+    }
+    // Paragraph property change revision — NOT recursed into when rendering previousProperties
+    if (!insidePropertyChange && pPr.propertyChange) {
+        xml.openNode("w:pPrChange", {
+            "w:id": String(pPr.propertyChange.revision.id),
+            "w:author": pPr.propertyChange.revision.author,
+            ...(pPr.propertyChange.revision.date ? { "w:date": pPr.propertyChange.revision.date } : {})
+        });
+        if (pPr.propertyChange.previousProperties) {
+            renderParagraphProperties(xml, pPr.propertyChange.previousProperties, true);
+        }
+        xml.closeNode();
+    }
+    if (pPr.markRunProperties) {
+        renderRunProperties(xml, pPr.markRunProperties);
+    }
+    xml.closeNode();
+}
+/** Render a hyperlink. */
+function renderHyperlink(xml, link) {
+    const attrs = {};
+    if (link.rId) {
+        attrs["r:id"] = link.rId;
+    }
+    if (link.anchor) {
+        attrs["w:anchor"] = link.anchor;
+    }
+    if (link.tooltip) {
+        attrs["w:tooltip"] = link.tooltip;
+    }
+    if (link.history) {
+        attrs["w:history"] = "1";
+    }
+    if (link.tgtFrame) {
+        attrs["w:tgtFrame"] = link.tgtFrame;
+    }
+    if (link.docLocation) {
+        attrs["w:docLocation"] = link.docLocation;
+    }
+    xml.openNode("w:hyperlink", attrs);
+    for (const run of link.children) {
+        renderRun(xml, run);
+    }
+    xml.closeNode();
+}
+/** Render a bookmark start. */
+function renderBookmarkStart(xml, bm) {
+    const attrs = {
+        "w:id": String(bm.id),
+        "w:name": bm.name
+    };
+    if (bm.colFirst !== undefined) {
+        attrs["w:colFirst"] = String(bm.colFirst);
+    }
+    if (bm.colLast !== undefined) {
+        attrs["w:colLast"] = String(bm.colLast);
+    }
+    if (bm.displacedByCustomXml) {
+        attrs["w:displacedByCustomXml"] = bm.displacedByCustomXml;
+    }
+    xml.leafNode("w:bookmarkStart", attrs);
+}
+/** Render a bookmark end. */
+function renderBookmarkEnd(xml, bm) {
+    xml.leafNode("w:bookmarkEnd", { "w:id": String(bm.id) });
+}
+/** Render comment range start. */
+function renderCommentRangeStart(xml, cr) {
+    xml.leafNode("w:commentRangeStart", { "w:id": String(cr.id) });
+}
+/** Render comment range end. */
+function renderCommentRangeEnd(xml, cr) {
+    xml.leafNode("w:commentRangeEnd", { "w:id": String(cr.id) });
+}
+/** Render comment reference (inside a run). */
+function renderCommentReference(xml, cr) {
+    xml.openNode("w:r");
+    xml.leafNode("w:commentReference", { "w:id": String(cr.id) });
+    xml.closeNode();
+}
+/** Render an inserted run (track changes). */
+function renderInsertedRun(xml, ins) {
+    const attrs = {
+        "w:id": String(ins.revision.id),
+        "w:author": ins.revision.author
+    };
+    if (ins.revision.date) {
+        attrs["w:date"] = ins.revision.date;
+    }
+    xml.openNode("w:ins", attrs);
+    renderRun(xml, ins.run);
+    xml.closeNode();
+}
+/** Render a deleted run (track changes). */
+function renderDeletedRun(xml, del) {
+    const attrs = {
+        "w:id": String(del.revision.id),
+        "w:author": del.revision.author
+    };
+    if (del.revision.date) {
+        attrs["w:date"] = del.revision.date;
+    }
+    xml.openNode("w:del", attrs);
+    // Deleted runs use w:delText instead of w:t
+    xml.openNode("w:r");
+    if (del.run.properties) {
+        renderRunProperties(xml, del.run.properties);
+    }
+    for (const content of del.run.content) {
+        if (content.type === "text") {
+            xml.openNode("w:delText", { "xml:space": "preserve" });
+            xml.writeText(content.text);
+            xml.closeNode();
+        }
+        else if (content.type === "break") {
+            const brAttrs = {};
+            if (content.breakType) {
+                brAttrs["w:type"] = content.breakType;
+            }
+            xml.leafNode("w:br", Object.keys(brAttrs).length > 0 ? brAttrs : undefined);
+        }
+        else if (content.type === "tab") {
+            xml.leafNode("w:tab");
+        }
+        else if (content.type === "carriageReturn") {
+            xml.leafNode("w:cr");
+        }
+        else if (content.type === "noBreakHyphen") {
+            xml.leafNode("w:noBreakHyphen");
+        }
+        else if (content.type === "softHyphen") {
+            xml.leafNode("w:softHyphen");
+        }
+    }
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render a moved-from or moved-to run (track changes). */
+function renderMovedRun(xml, moved, wrapperTag) {
+    const attrs = {
+        "w:id": String(moved.revision.id),
+        "w:author": moved.revision.author
+    };
+    if (moved.revision.date) {
+        attrs["w:date"] = moved.revision.date;
+    }
+    xml.openNode(wrapperTag, attrs);
+    renderRun(xml, moved.run);
+    xml.closeNode();
+}
+/** Render a paragraph child element. */
+function renderParagraphChild(xml, child) {
+    if ("type" in child) {
+        switch (child.type) {
+            case "hyperlink":
+                renderHyperlink(xml, child);
+                return;
+            case "bookmarkStart":
+                renderBookmarkStart(xml, child);
+                return;
+            case "bookmarkEnd":
+                renderBookmarkEnd(xml, child);
+                return;
+            case "commentRangeStart":
+                renderCommentRangeStart(xml, child);
+                return;
+            case "commentRangeEnd":
+                renderCommentRangeEnd(xml, child);
+                return;
+            case "commentReference":
+                renderCommentReference(xml, child);
+                return;
+            case "insertedRun":
+                renderInsertedRun(xml, child);
+                return;
+            case "deletedRun":
+                renderDeletedRun(xml, child);
+                return;
+            case "movedFromRun":
+                renderMovedRun(xml, child, "w:moveFrom");
+                return;
+            case "movedToRun":
+                renderMovedRun(xml, child, "w:moveTo");
+                return;
+            case "moveFromRangeStart":
+            case "moveFromRangeEnd":
+            case "moveToRangeStart":
+            case "moveToRangeEnd": {
+                const moveAttrs = {
+                    "w:id": String(child.id)
+                };
+                if (child.author) {
+                    moveAttrs["w:author"] = child.author;
+                }
+                if (child.date) {
+                    moveAttrs["w:date"] = child.date;
+                }
+                if (child.name) {
+                    moveAttrs["w:name"] = child.name;
+                }
+                xml.leafNode(`w:${child.type}`, moveAttrs);
+                return;
+            }
+            case "customXmlInsRangeStart":
+            case "customXmlInsRangeEnd":
+            case "customXmlDelRangeStart":
+            case "customXmlDelRangeEnd":
+            case "customXmlMoveFromRangeStart":
+            case "customXmlMoveFromRangeEnd":
+            case "customXmlMoveToRangeStart":
+            case "customXmlMoveToRangeEnd": {
+                const cmAttrs = {
+                    "w:id": String(child.id)
+                };
+                if (child.author) {
+                    cmAttrs["w:author"] = child.author;
+                }
+                if (child.date) {
+                    cmAttrs["w:date"] = child.date;
+                }
+                xml.leafNode(`w:${child.type}`, cmAttrs);
+                return;
+            }
+            default:
+                break;
+        }
+    }
+    // Run objects don't have a .type property at the union level, but we handle
+    // them via duck typing: they have .content
+    if ("content" in child && !("type" in child)) {
+        renderRun(xml, child);
+    }
+}
+/** Render a w:p element. */
+export function renderParagraph(xml, para) {
+    const pAttrs = {};
+    if (para.paraId) {
+        pAttrs["w14:paraId"] = para.paraId;
+    }
+    if (para.textId) {
+        pAttrs["w14:textId"] = para.textId;
+    }
+    xml.openNode("w:p", Object.keys(pAttrs).length > 0 ? pAttrs : undefined);
+    if (para.properties) {
+        renderParagraphProperties(xml, para.properties);
+    }
+    for (const child of para.children) {
+        renderParagraphChild(xml, child);
+    }
+    xml.closeNode();
+}