@cj-tech-master/excelts 9.4.2 → 9.5.0

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

@@ -0,0 +1,238 @@
+/**
+ * DOCX Writers - Section Properties
+ *
+ * Renders w:sectPr element including page size, margins, columns,
+ * headers/footers, page numbering, page borders, vertical alignment, etc.
+ */
+import { DEFAULT_PAGE_WIDTH, DEFAULT_PAGE_HEIGHT, DEFAULT_MARGIN, DEFAULT_HEADER_FOOTER_MARGIN, DEFAULT_COLUMN_SPACE } from "../constants.js";
+import { renderBorderElement } from "./run-writer.js";
+/** Render footnote/endnote properties. */
+function renderNoteProperties(xml, tagName, props) {
+    xml.openNode(tagName);
+    if (props.position) {
+        xml.leafNode("w:pos", { "w:val": props.position });
+    }
+    if (props.numFmt) {
+        xml.leafNode("w:numFmt", { "w:val": props.numFmt });
+    }
+    if (props.numStart !== undefined) {
+        xml.leafNode("w:numStart", { "w:val": String(props.numStart) });
+    }
+    if (props.numRestart) {
+        xml.leafNode("w:numRestart", { "w:val": props.numRestart });
+    }
+    xml.closeNode();
+}
+/** Render a header or footer reference. */
+function renderHeaderFooterRef(xml, tagName, ref) {
+    xml.leafNode(tagName, { "w:type": ref.type, "r:id": ref.rId });
+}
+/** Render column layout. */
+function renderColumns(xml, cols) {
+    const attrs = {};
+    if (cols.space !== undefined) {
+        attrs["w:space"] = String(cols.space);
+    }
+    if (cols.count !== undefined) {
+        attrs["w:num"] = String(cols.count);
+    }
+    if (cols.equalWidth !== undefined) {
+        attrs["w:equalWidth"] = cols.equalWidth ? "1" : "0";
+    }
+    if (cols.separator) {
+        attrs["w:sep"] = "1";
+    }
+    if (cols.columns && cols.columns.length > 0) {
+        xml.openNode("w:cols", attrs);
+        for (const col of cols.columns) {
+            const colAttrs = { "w:w": String(col.width) };
+            if (col.space !== undefined) {
+                colAttrs["w:space"] = String(col.space);
+            }
+            xml.leafNode("w:col", colAttrs);
+        }
+        xml.closeNode();
+    }
+    else {
+        xml.leafNode("w:cols", attrs);
+    }
+}
+/** Render page borders (w:pgBorders). */
+function renderPageBorders(xml, borders) {
+    const attrs = {};
+    if (borders.display) {
+        attrs["w:display"] = borders.display;
+    }
+    if (borders.offsetFrom) {
+        attrs["w:offsetFrom"] = borders.offsetFrom;
+    }
+    if (borders.zOrder) {
+        attrs["w:zOrder"] = borders.zOrder;
+    }
+    xml.openNode("w:pgBorders", Object.keys(attrs).length > 0 ? attrs : undefined);
+    if (borders.top) {
+        renderBorderElement(xml, "w:top", borders.top);
+    }
+    if (borders.left) {
+        renderBorderElement(xml, "w:left", borders.left);
+    }
+    if (borders.bottom) {
+        renderBorderElement(xml, "w:bottom", borders.bottom);
+    }
+    if (borders.right) {
+        renderBorderElement(xml, "w:right", borders.right);
+    }
+    xml.closeNode();
+}
+/** Render w:sectPr element. */
+export function renderSectionProperties(xml, sect, insidePropertyChange = false) {
+    xml.openNode("w:sectPr");
+    // Header references
+    if (sect.headers) {
+        for (const ref of sect.headers) {
+            renderHeaderFooterRef(xml, "w:headerReference", ref);
+        }
+    }
+    // Footer references
+    if (sect.footers) {
+        for (const ref of sect.footers) {
+            renderHeaderFooterRef(xml, "w:footerReference", ref);
+        }
+    }
+    // Section break type
+    if (sect.breakType) {
+        xml.leafNode("w:type", { "w:val": sect.breakType });
+    }
+    // Page size
+    {
+        const ps = sect.pageSize;
+        const w = ps?.width ?? DEFAULT_PAGE_WIDTH;
+        const h = ps?.height ?? DEFAULT_PAGE_HEIGHT;
+        const attrs = { "w:w": String(w), "w:h": String(h) };
+        if (ps?.orientation === "landscape") {
+            attrs["w:orient"] = "landscape";
+        }
+        xml.leafNode("w:pgSz", attrs);
+    }
+    // Page margins
+    {
+        const m = sect.margins;
+        xml.leafNode("w:pgMar", {
+            "w:top": String(m?.top ?? DEFAULT_MARGIN),
+            "w:right": String(m?.right ?? DEFAULT_MARGIN),
+            "w:bottom": String(m?.bottom ?? DEFAULT_MARGIN),
+            "w:left": String(m?.left ?? DEFAULT_MARGIN),
+            "w:header": String(m?.header ?? DEFAULT_HEADER_FOOTER_MARGIN),
+            "w:footer": String(m?.footer ?? DEFAULT_HEADER_FOOTER_MARGIN),
+            "w:gutter": String(m?.gutter ?? 0)
+        });
+    }
+    // Page borders
+    if (sect.pageBorders) {
+        renderPageBorders(xml, sect.pageBorders);
+    }
+    // Columns
+    if (sect.columns) {
+        renderColumns(xml, sect.columns);
+    }
+    else {
+        xml.leafNode("w:cols", { "w:space": String(DEFAULT_COLUMN_SPACE) });
+    }
+    // Title page (different first page header/footer)
+    if (sect.titlePage) {
+        xml.leafNode("w:titlePg");
+    }
+    // Page numbering
+    if (sect.pageNumbering) {
+        const attrs = {};
+        if (sect.pageNumbering.start !== undefined) {
+            attrs["w:start"] = String(sect.pageNumbering.start);
+        }
+        if (sect.pageNumbering.format) {
+            attrs["w:fmt"] = sect.pageNumbering.format;
+        }
+        xml.leafNode("w:pgNumType", attrs);
+    }
+    // Line numbers
+    if (sect.lineNumbers) {
+        const attrs = {};
+        if (sect.lineNumbers.countBy !== undefined) {
+            attrs["w:countBy"] = String(sect.lineNumbers.countBy);
+        }
+        if (sect.lineNumbers.start !== undefined) {
+            attrs["w:start"] = String(sect.lineNumbers.start);
+        }
+        if (sect.lineNumbers.restart) {
+            attrs["w:restart"] = sect.lineNumbers.restart;
+        }
+        if (sect.lineNumbers.distance !== undefined) {
+            attrs["w:distance"] = String(sect.lineNumbers.distance);
+        }
+        xml.leafNode("w:lnNumType", attrs);
+    }
+    // Vertical alignment
+    if (sect.verticalAlign) {
+        xml.leafNode("w:vAlign", { "w:val": sect.verticalAlign });
+    }
+    // Text direction
+    if (sect.textDirection) {
+        xml.leafNode("w:textDirection", { "w:val": sect.textDirection });
+    }
+    // Section-level bidi (RTL)
+    if (sect.bidi) {
+        xml.leafNode("w:bidi");
+    }
+    // RTL gutter
+    if (sect.rtlGutter) {
+        xml.leafNode("w:rtlGutter");
+    }
+    // Form protection
+    if (sect.formProtection) {
+        xml.leafNode("w:formProt", { "w:val": "1" });
+    }
+    // Footnote properties
+    if (sect.footnoteProperties) {
+        renderNoteProperties(xml, "w:footnotePr", sect.footnoteProperties);
+    }
+    // Endnote properties
+    if (sect.endnoteProperties) {
+        renderNoteProperties(xml, "w:endnotePr", sect.endnoteProperties);
+    }
+    // Document grid
+    if (sect.docGrid) {
+        const gridAttrs = {
+            "w:linePitch": String(sect.docGrid.linePitch ?? 360)
+        };
+        if (sect.docGrid.charSpace !== undefined) {
+            gridAttrs["w:charSpace"] = String(sect.docGrid.charSpace);
+        }
+        if (sect.docGrid.type) {
+            gridAttrs["w:type"] = sect.docGrid.type;
+        }
+        xml.leafNode("w:docGrid", gridAttrs);
+    }
+    else {
+        xml.leafNode("w:docGrid", { "w:linePitch": "360" });
+    }
+    // Section property change (track changes)
+    if (!insidePropertyChange && sect.propertyChange) {
+        const rev = sect.propertyChange.revision;
+        const attrs = {
+            "w:id": String(rev.id),
+            "w:author": rev.author
+        };
+        if (rev.date) {
+            attrs["w:date"] = rev.date;
+        }
+        xml.openNode("w:sectPrChange", attrs);
+        if (sect.propertyChange.previousProperties) {
+            renderSectionProperties(xml, sect.propertyChange.previousProperties, true);
+        }
+        else {
+            xml.openNode("w:sectPr");
+            xml.closeNode();
+        }
+        xml.closeNode();
+    }
+    xml.closeNode();
+}

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

@@ -0,0 +1,242 @@
+/**
+ * DOCX Writers - Styles
+ *
+ * Renders word/styles.xml including document defaults, style definitions,
+ * and table style conditional formats.
+ */
+import { NS_W, NS_R, STD_DOC_ATTRIBUTES } from "../constants.js";
+import { renderParagraphProperties } from "./paragraph-writer.js";
+import { renderRunProperties, renderShading } from "./run-writer.js";
+/** Render document defaults. */
+function renderDocDefaults(xml, defaults) {
+    xml.openNode("w:docDefaults");
+    if (defaults.runProperties) {
+        xml.openNode("w:rPrDefault");
+        renderRunProperties(xml, defaults.runProperties);
+        xml.closeNode();
+    }
+    if (defaults.paragraphProperties) {
+        xml.openNode("w:pPrDefault");
+        renderParagraphProperties(xml, defaults.paragraphProperties);
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/** Map table style condition type to OOXML value. */
+const CONDITION_TYPE_MAP = {
+    firstRow: "firstRow",
+    lastRow: "lastRow",
+    firstColumn: "firstCol",
+    lastColumn: "lastCol",
+    oddRowBanding: "band1Horz",
+    evenRowBanding: "band2Horz",
+    oddColumnBanding: "band1Vert",
+    evenColumnBanding: "band2Vert",
+    topLeftCell: "nwCell",
+    topRightCell: "neCell",
+    bottomLeftCell: "swCell",
+    bottomRightCell: "seCell"
+};
+/** Render table style conditional format (w:tblStylePr). */
+function renderTableStyleCondition(xml, condition) {
+    const typeVal = CONDITION_TYPE_MAP[condition.type] ?? condition.type;
+    xml.openNode("w:tblStylePr", { "w:type": typeVal });
+    if (condition.paragraphProperties) {
+        renderParagraphProperties(xml, condition.paragraphProperties);
+    }
+    if (condition.runProperties) {
+        renderRunProperties(xml, condition.runProperties);
+    }
+    if (condition.tableProperties) {
+        xml.openNode("w:tblPr");
+        // Simplified table props for conditional format
+        if (condition.tableProperties.borders) {
+            renderTableBordersInStyle(xml, condition.tableProperties.borders);
+        }
+        xml.closeNode();
+    }
+    if (condition.cellProperties) {
+        xml.openNode("w:tcPr");
+        if (condition.cellProperties.shading) {
+            renderShading(xml, condition.cellProperties.shading);
+        }
+        if (condition.cellProperties.borders) {
+            renderTableBordersInStyle(xml, condition.cellProperties.borders);
+        }
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/** Render table borders inside a style definition. */
+function renderTableBordersInStyle(xml, borders) {
+    xml.openNode("w:tblBorders");
+    for (const side of ["top", "left", "bottom", "right", "insideH", "insideV"]) {
+        const b = borders[side];
+        if (b) {
+            xml.leafNode(`w:${side}`, {
+                "w:val": b.style,
+                "w:sz": String(b.size ?? 4),
+                "w:space": String(b.space ?? 0),
+                "w:color": b.color ?? "auto"
+            });
+        }
+    }
+    xml.closeNode();
+}
+/** Render a single style definition. */
+function renderStyle(xml, style) {
+    const attrs = {
+        "w:type": style.type,
+        "w:styleId": style.styleId
+    };
+    if (style.isDefault) {
+        attrs["w:default"] = "1";
+    }
+    if (style.customStyle) {
+        attrs["w:customStyle"] = "1";
+    }
+    xml.openNode("w:style", attrs);
+    xml.leafNode("w:name", { "w:val": style.name });
+    if (style.basedOn) {
+        xml.leafNode("w:basedOn", { "w:val": style.basedOn });
+    }
+    if (style.next) {
+        xml.leafNode("w:next", { "w:val": style.next });
+    }
+    if (style.link) {
+        xml.leafNode("w:link", { "w:val": style.link });
+    }
+    if (style.autoRedefine) {
+        xml.leafNode("w:autoRedefine");
+    }
+    if (style.hidden) {
+        xml.leafNode("w:hidden");
+    }
+    if (style.uiPriority !== undefined) {
+        xml.leafNode("w:uiPriority", { "w:val": String(style.uiPriority) });
+    }
+    if (style.semiHidden) {
+        xml.leafNode("w:semiHidden");
+    }
+    if (style.unhideWhenUsed) {
+        xml.leafNode("w:unhideWhenUsed");
+    }
+    if (style.qFormat) {
+        xml.leafNode("w:qFormat");
+    }
+    if (style.locked) {
+        xml.leafNode("w:locked");
+    }
+    if (style.outlineLevel !== undefined) {
+        xml.leafNode("w:outlineLvl", { "w:val": String(style.outlineLevel) });
+    }
+    if (style.paragraphProperties) {
+        renderParagraphProperties(xml, style.paragraphProperties);
+    }
+    if (style.runProperties) {
+        renderRunProperties(xml, style.runProperties);
+    }
+    // For table styles
+    if (style.tableProperties) {
+        xml.openNode("w:tblPr");
+        if (style.tableProperties.width) {
+            xml.leafNode("w:tblW", {
+                "w:w": String(style.tableProperties.width.value),
+                "w:type": style.tableProperties.width.type
+            });
+        }
+        if (style.tableProperties.alignment) {
+            xml.leafNode("w:jc", { "w:val": style.tableProperties.alignment });
+        }
+        if (style.tableProperties.indent !== undefined) {
+            xml.leafNode("w:tblInd", {
+                "w:w": String(style.tableProperties.indent),
+                "w:type": "dxa"
+            });
+        }
+        if (style.tableProperties.layout) {
+            xml.leafNode("w:tblLayout", { "w:type": style.tableProperties.layout });
+        }
+        if (style.tableProperties.borders) {
+            renderTableBordersInStyle(xml, style.tableProperties.borders);
+        }
+        if (style.tableProperties.cellMargins) {
+            xml.openNode("w:tblCellMar");
+            for (const side of ["top", "left", "bottom", "right"]) {
+                const m = style.tableProperties.cellMargins[side];
+                if (m) {
+                    xml.leafNode(`w:${side}`, { "w:w": String(m.value), "w:type": m.type });
+                }
+            }
+            xml.closeNode();
+        }
+        if (style.tableProperties.cellSpacing) {
+            xml.leafNode("w:tblCellSpacing", {
+                "w:w": String(style.tableProperties.cellSpacing.value),
+                "w:type": style.tableProperties.cellSpacing.type
+            });
+        }
+        if (style.tableProperties.shading) {
+            const shd = style.tableProperties.shading;
+            const shdAttrs = {
+                "w:val": shd.pattern ?? "clear",
+                "w:fill": shd.fill ?? "auto"
+            };
+            if (shd.color) {
+                shdAttrs["w:color"] = shd.color;
+            }
+            xml.leafNode("w:shd", shdAttrs);
+        }
+        if (style.tableProperties.look) {
+            const look = style.tableProperties.look;
+            const lookAttrs = {};
+            if (look.firstRow !== undefined) {
+                lookAttrs["w:firstRow"] = look.firstRow ? "1" : "0";
+            }
+            if (look.lastRow !== undefined) {
+                lookAttrs["w:lastRow"] = look.lastRow ? "1" : "0";
+            }
+            if (look.firstColumn !== undefined) {
+                lookAttrs["w:firstColumn"] = look.firstColumn ? "1" : "0";
+            }
+            if (look.lastColumn !== undefined) {
+                lookAttrs["w:lastColumn"] = look.lastColumn ? "1" : "0";
+            }
+            if (look.noHBand !== undefined) {
+                lookAttrs["w:noHBand"] = look.noHBand ? "1" : "0";
+            }
+            if (look.noVBand !== undefined) {
+                lookAttrs["w:noVBand"] = look.noVBand ? "1" : "0";
+            }
+            xml.leafNode("w:tblLook", lookAttrs);
+        }
+        if (style.tableProperties.visuallyRightToLeft) {
+            xml.leafNode("w:bidiVisual");
+        }
+        xml.closeNode();
+    }
+    // Table style conditional formats
+    if (style.tableStyleConditions) {
+        for (const cond of style.tableStyleConditions) {
+            renderTableStyleCondition(xml, cond);
+        }
+    }
+    xml.closeNode();
+}
+/** Render word/styles.xml. */
+export function renderStyles(xml, docDefaults, styles) {
+    xml.openXml(STD_DOC_ATTRIBUTES);
+    xml.openNode("w:styles", {
+        "xmlns:w": NS_W,
+        "xmlns:r": NS_R
+    });
+    if (docDefaults) {
+        renderDocDefaults(xml, docDefaults);
+    }
+    if (styles) {
+        for (const style of styles) {
+            renderStyle(xml, style);
+        }
+    }
+    xml.closeNode();
+}