@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/cjs/modules/word/writers/chart-writer.js

@@ -0,0 +1,388 @@
+"use strict";
+/**
+ * DOCX Module - Chart Writer
+ *
+ * Generates DrawingML chart part XML (word/charts/chartN.xml) from
+ * high-level Chart definitions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderChartPart = renderChartPart;
+const constants_1 = require("../constants");
+const NS_C = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+const NS_A_LOCAL = "http://schemas.openxmlformats.org/drawingml/2006/main";
+const NS_R_LOCAL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+const CHART_TYPE_CATEGORY = {
+    bar: { tag: "barChart", direction: "bar", grouping: "clustered" },
+    barStacked: { tag: "barChart", direction: "bar", grouping: "stacked" },
+    barPercentStacked: { tag: "barChart", direction: "bar", grouping: "percentStacked" },
+    column: { tag: "barChart", direction: "col", grouping: "clustered" },
+    columnStacked: { tag: "barChart", direction: "col", grouping: "stacked" },
+    columnPercentStacked: { tag: "barChart", direction: "col", grouping: "percentStacked" },
+    line: { tag: "lineChart", grouping: "standard" },
+    lineStacked: { tag: "lineChart", grouping: "stacked" },
+    lineMarked: { tag: "lineChart", grouping: "standard", marked: true },
+    area: { tag: "areaChart", grouping: "standard" },
+    areaStacked: { tag: "areaChart", grouping: "stacked" },
+    pie: { tag: "pieChart" },
+    pie3D: { tag: "pie3DChart" },
+    doughnut: { tag: "doughnutChart" },
+    scatter: { tag: "scatterChart", scatterStyle: "marker" },
+    scatterSmooth: { tag: "scatterChart", scatterStyle: "smoothMarker" },
+    radar: { tag: "radarChart" }
+};
+/** Render a chart part (word/charts/chartN.xml). */
+function renderChartPart(xml, chart) {
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("c:chartSpace", {
+        "xmlns:c": NS_C,
+        "xmlns:a": NS_A_LOCAL,
+        "xmlns:r": NS_R_LOCAL
+    });
+    // Date1904 (calendar base)
+    xml.leafNode("c:date1904", { val: "0" });
+    // Language
+    xml.leafNode("c:lang", { val: "en-US" });
+    // Round text
+    xml.leafNode("c:roundedCorners", { val: "0" });
+    // Chart style (optional, defaults to 2)
+    if (chart.style !== undefined) {
+        xml.openNode("mc:AlternateContent", {
+            "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006"
+        });
+        xml.openNode("mc:Choice", {
+            Requires: "c14",
+            "xmlns:c14": "http://schemas.microsoft.com/office/drawing/2007/8/2/chart"
+        });
+        xml.leafNode("c14:style", { val: String(chart.style) });
+        xml.closeNode();
+        xml.openNode("mc:Fallback");
+        xml.leafNode("c:style", { val: String(Math.min(chart.style, 48)) });
+        xml.closeNode();
+        xml.closeNode();
+    }
+    // Chart
+    xml.openNode("c:chart");
+    // Title
+    if (chart.title) {
+        renderTitle(xml, chart.title);
+        xml.leafNode("c:autoTitleDeleted", { val: "0" });
+    }
+    else {
+        xml.leafNode("c:autoTitleDeleted", { val: "1" });
+    }
+    // 3D view
+    if (chart.view3d) {
+        xml.openNode("c:view3D");
+        xml.leafNode("c:rotX", { val: "15" });
+        xml.leafNode("c:rotY", { val: "20" });
+        xml.leafNode("c:depthPercent", { val: "100" });
+        xml.leafNode("c:rAngAx", { val: "1" });
+        xml.closeNode();
+    }
+    // Plot area
+    xml.openNode("c:plotArea");
+    xml.leafNode("c:layout");
+    // Chart type-specific rendering
+    const catAxId = "111111111";
+    const valAxId = "222222222";
+    renderChartTypeElement(xml, chart, catAxId, valAxId);
+    // Axes (unless pie/doughnut which use no axes)
+    const noAxes = chart.type === "pie" || chart.type === "pie3D" || chart.type === "doughnut";
+    if (!noAxes) {
+        // Category axis
+        renderAxis(xml, "catAx", catAxId, valAxId, chart.categoryAxis, "b");
+        // Value axis
+        renderAxis(xml, "valAx", valAxId, catAxId, chart.valueAxis, "l");
+    }
+    // Plot area background
+    if (chart.plotAreaColor) {
+        xml.openNode("c:spPr");
+        xml.openNode("a:solidFill");
+        xml.leafNode("a:srgbClr", { val: chart.plotAreaColor });
+        xml.closeNode();
+        xml.closeNode();
+    }
+    xml.closeNode(); // c:plotArea
+    // Legend
+    if (chart.legend !== "none") {
+        xml.openNode("c:legend");
+        xml.leafNode("c:legendPos", { val: chart.legend ?? "r" });
+        xml.leafNode("c:overlay", { val: "0" });
+        xml.closeNode();
+    }
+    xml.leafNode("c:plotVisOnly", { val: "1" });
+    xml.leafNode("c:dispBlanksAs", { val: "gap" });
+    xml.closeNode(); // c:chart
+    // Chart area background
+    if (chart.chartAreaColor) {
+        xml.openNode("c:spPr");
+        xml.openNode("a:solidFill");
+        xml.leafNode("a:srgbClr", { val: chart.chartAreaColor });
+        xml.closeNode();
+        xml.closeNode();
+    }
+    xml.closeNode(); // c:chartSpace
+}
+function renderTitle(xml, title) {
+    xml.openNode("c:title");
+    xml.openNode("c:tx");
+    xml.openNode("c:rich");
+    xml.leafNode("a:bodyPr", {
+        rot: "0",
+        spcFirstLastPara: "1",
+        vertOverflow: "ellipsis",
+        wrap: "square",
+        anchor: "ctr",
+        anchorCtr: "1"
+    });
+    xml.leafNode("a:lstStyle");
+    xml.openNode("a:p");
+    xml.openNode("a:pPr");
+    xml.leafNode("a:defRPr", {
+        sz: "1400",
+        b: "0",
+        i: "0",
+        u: "none",
+        strike: "noStrike",
+        kern: "1200",
+        spc: "0",
+        baseline: "0"
+    });
+    xml.closeNode();
+    xml.openNode("a:r");
+    xml.leafNode("a:rPr", { lang: "en-US" });
+    xml.openNode("a:t");
+    xml.writeText(title);
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // c:rich
+    xml.closeNode(); // c:tx
+    xml.leafNode("c:overlay", { val: "0" });
+    xml.closeNode(); // c:title
+}
+function renderChartTypeElement(xml, chart, catAxId, valAxId) {
+    const info = CHART_TYPE_CATEGORY[chart.type] ?? { tag: "barChart" };
+    const tagName = `c:${info.tag}`;
+    xml.openNode(tagName);
+    // Direction (bar vs col)
+    if ("direction" in info && info.direction) {
+        xml.leafNode("c:barDir", { val: info.direction });
+    }
+    // Grouping (stacked/clustered/percentStacked)
+    if ("grouping" in info && info.grouping) {
+        xml.leafNode("c:grouping", { val: info.grouping });
+    }
+    // Scatter style
+    if ("scatterStyle" in info && info.scatterStyle) {
+        xml.leafNode("c:scatterStyle", { val: info.scatterStyle });
+    }
+    xml.leafNode("c:varyColors", {
+        val: chart.type === "pie" || chart.type === "pie3D" || chart.type === "doughnut" ? "1" : "0"
+    });
+    // Series
+    chart.series.forEach((series, idx) => {
+        renderSeries(xml, series, idx, chart.type, "marked" in info && info.marked);
+    });
+    // Gap width / overlap (bar/column)
+    if (info.tag === "barChart") {
+        xml.leafNode("c:gapWidth", { val: "150" });
+        if (chart.type === "barStacked" ||
+            chart.type === "barPercentStacked" ||
+            chart.type === "columnStacked" ||
+            chart.type === "columnPercentStacked") {
+            xml.leafNode("c:overlap", { val: "100" });
+        }
+    }
+    // Axes IDs
+    const noAxes = chart.type === "pie" || chart.type === "pie3D" || chart.type === "doughnut";
+    if (!noAxes) {
+        xml.leafNode("c:axId", { val: catAxId });
+        xml.leafNode("c:axId", { val: valAxId });
+    }
+    xml.closeNode(); // chart type tag
+}
+function renderSeries(xml, series, index, chartType, markedLine) {
+    xml.openNode("c:ser");
+    xml.leafNode("c:idx", { val: String(index) });
+    xml.leafNode("c:order", { val: String(index) });
+    // Series name
+    xml.openNode("c:tx");
+    xml.openNode("c:strRef");
+    xml.openNode("c:f");
+    xml.writeText(`Sheet1!$${String.fromCharCode(66 + index)}$1`);
+    xml.closeNode();
+    xml.openNode("c:strCache");
+    xml.leafNode("c:ptCount", { val: "1" });
+    xml.openNode("c:pt", { idx: "0" });
+    xml.openNode("c:v");
+    xml.writeText(series.name);
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // c:tx
+    // Series fill color
+    if (series.color) {
+        xml.openNode("c:spPr");
+        xml.openNode("a:solidFill");
+        xml.leafNode("a:srgbClr", { val: series.color });
+        xml.closeNode();
+        if (chartType.startsWith("line") || chartType === "scatter" || chartType === "scatterSmooth") {
+            xml.openNode("a:ln", { w: "28575" });
+            xml.openNode("a:solidFill");
+            xml.leafNode("a:srgbClr", { val: series.color });
+            xml.closeNode();
+            xml.closeNode();
+        }
+        xml.closeNode();
+    }
+    // Per-point colors (for pie)
+    if (series.pointColors && series.pointColors.length > 0) {
+        series.pointColors.forEach((color, i) => {
+            xml.openNode("c:dPt");
+            xml.leafNode("c:idx", { val: String(i) });
+            xml.leafNode("c:bubble3D", { val: "0" });
+            xml.openNode("c:spPr");
+            xml.openNode("a:solidFill");
+            xml.leafNode("a:srgbClr", { val: color });
+            xml.closeNode();
+            xml.closeNode();
+            xml.closeNode();
+        });
+    }
+    // Markers for line charts
+    if (markedLine) {
+        xml.openNode("c:marker");
+        xml.leafNode("c:symbol", { val: "circle" });
+        xml.leafNode("c:size", { val: "5" });
+        xml.closeNode();
+    }
+    else if (chartType.startsWith("line")) {
+        xml.openNode("c:marker");
+        xml.leafNode("c:symbol", { val: "none" });
+        xml.closeNode();
+    }
+    // Smooth for line/scatter smooth
+    if (chartType === "scatterSmooth") {
+        xml.leafNode("c:smooth", { val: "1" });
+    }
+    // Data labels
+    if (series.showDataLabels) {
+        xml.openNode("c:dLbls");
+        xml.leafNode("c:showLegendKey", { val: "0" });
+        xml.leafNode("c:showVal", { val: "1" });
+        xml.leafNode("c:showCatName", { val: "0" });
+        xml.leafNode("c:showSerName", { val: "0" });
+        xml.leafNode("c:showPercent", { val: "0" });
+        xml.leafNode("c:showBubbleSize", { val: "0" });
+        xml.closeNode();
+    }
+    // Categories (c:cat)
+    if (chartType !== "scatter" && chartType !== "scatterSmooth") {
+        xml.openNode("c:cat");
+        xml.openNode("c:strRef");
+        xml.openNode("c:f");
+        xml.writeText(`Sheet1!$A$2:$A$${series.categories.length + 1}`);
+        xml.closeNode();
+        xml.openNode("c:strCache");
+        xml.leafNode("c:ptCount", { val: String(series.categories.length) });
+        series.categories.forEach((cat, i) => {
+            xml.openNode("c:pt", { idx: String(i) });
+            xml.openNode("c:v");
+            xml.writeText(cat);
+            xml.closeNode();
+            xml.closeNode();
+        });
+        xml.closeNode();
+        xml.closeNode();
+        xml.closeNode();
+    }
+    else {
+        // For scatter: xVal
+        xml.openNode("c:xVal");
+        xml.openNode("c:numRef");
+        xml.openNode("c:f");
+        xml.writeText(`Sheet1!$A$2:$A$${series.categories.length + 1}`);
+        xml.closeNode();
+        xml.openNode("c:numCache");
+        xml.leafNode("c:formatCode", { val: "General" });
+        xml.leafNode("c:ptCount", { val: String(series.categories.length) });
+        series.categories.forEach((cat, i) => {
+            xml.openNode("c:pt", { idx: String(i) });
+            xml.openNode("c:v");
+            xml.writeText(cat);
+            xml.closeNode();
+            xml.closeNode();
+        });
+        xml.closeNode();
+        xml.closeNode();
+        xml.closeNode();
+    }
+    // Values (c:val or c:yVal)
+    const valTag = chartType === "scatter" || chartType === "scatterSmooth" ? "c:yVal" : "c:val";
+    xml.openNode(valTag);
+    xml.openNode("c:numRef");
+    xml.openNode("c:f");
+    xml.writeText(`Sheet1!$B$2:$B$${series.values.length + 1}`);
+    xml.closeNode();
+    xml.openNode("c:numCache");
+    xml.leafNode("c:formatCode", { val: "General" });
+    xml.leafNode("c:ptCount", { val: String(series.values.length) });
+    series.values.forEach((val, i) => {
+        xml.openNode("c:pt", { idx: String(i) });
+        xml.openNode("c:v");
+        xml.writeText(String(val));
+        xml.closeNode();
+        xml.closeNode();
+    });
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // c:ser
+}
+function renderAxis(xml, tagName, axId, crossAxId, axis, defaultPos) {
+    xml.openNode(`c:${tagName}`);
+    xml.leafNode("c:axId", { val: axId });
+    // Scaling
+    xml.openNode("c:scaling");
+    xml.leafNode("c:orientation", { val: "minMax" });
+    if (axis?.min !== undefined) {
+        xml.leafNode("c:min", { val: String(axis.min) });
+    }
+    if (axis?.max !== undefined) {
+        xml.leafNode("c:max", { val: String(axis.max) });
+    }
+    xml.closeNode();
+    xml.leafNode("c:delete", { val: axis?.hidden ? "1" : "0" });
+    xml.leafNode("c:axPos", { val: defaultPos });
+    // Title
+    if (axis?.title) {
+        renderTitle(xml, axis.title);
+    }
+    // Number format
+    if (axis?.numberFormat) {
+        xml.leafNode("c:numFmt", { formatCode: axis.numberFormat, sourceLinked: "0" });
+    }
+    else {
+        xml.leafNode("c:numFmt", { formatCode: "General", sourceLinked: "1" });
+    }
+    xml.leafNode("c:majorTickMark", { val: "out" });
+    xml.leafNode("c:minorTickMark", { val: "none" });
+    xml.leafNode("c:tickLblPos", { val: "nextTo" });
+    xml.leafNode("c:crossAx", { val: crossAxId });
+    xml.leafNode("c:crosses", { val: "autoZero" });
+    if (tagName === "catAx") {
+        xml.leafNode("c:auto", { val: "1" });
+        xml.leafNode("c:lblAlgn", { val: "ctr" });
+        xml.leafNode("c:lblOffset", { val: "100" });
+        xml.leafNode("c:noMultiLvlLbl", { val: "0" });
+    }
+    else {
+        xml.leafNode("c:crossBetween", { val: "between" });
+        if (axis?.majorUnit) {
+            xml.leafNode("c:majorUnit", { val: String(axis.majorUnit) });
+        }
+    }
+    xml.closeNode();
+}

package/dist/cjs/modules/word/writers/checkbox-writer.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * DOCX Writers - CheckBox
+ *
+ * Renders checkbox as a structured document tag (SDT) with w14:checkbox.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCheckBox = renderCheckBox;
+const constants_1 = require("../constants");
+/** Render a checkbox as a paragraph with SDT. */
+function renderCheckBox(xml, cb) {
+    const checked = cb.checked ?? false;
+    const checkedChar = cb.checkedState?.value ?? "2612"; // ☒
+    const uncheckedChar = cb.uncheckedState?.value ?? "2610"; // ☐
+    const checkedFont = cb.checkedState?.font ?? "MS Gothic";
+    const uncheckedFont = cb.uncheckedState?.font ?? "MS Gothic";
+    const displayChar = checked ? checkedChar : uncheckedChar;
+    const displayFont = checked ? checkedFont : uncheckedFont;
+    xml.openNode("w:sdt");
+    // SDT properties
+    xml.openNode("w:sdtPr");
+    xml.openNode("w14:checkbox", { "xmlns:w14": constants_1.NS_W14 });
+    xml.leafNode("w14:checked", { "w14:val": checked ? "1" : "0" });
+    xml.leafNode("w14:checkedState", { "w14:val": checkedChar, "w14:font": checkedFont });
+    xml.leafNode("w14:uncheckedState", { "w14:val": uncheckedChar, "w14:font": uncheckedFont });
+    xml.closeNode();
+    xml.closeNode();
+    // SDT content - display the checkbox character
+    xml.openNode("w:sdtContent");
+    xml.openNode("w:r");
+    xml.openNode("w:rPr");
+    xml.leafNode("w:rFonts", {
+        "w:ascii": displayFont,
+        "w:hAnsi": displayFont,
+        "w:eastAsia": displayFont
+    });
+    xml.closeNode();
+    xml.openNode("w:t");
+    // Convert hex code point to character
+    xml.writeText(String.fromCodePoint(parseInt(displayChar, 16)));
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // w:sdt
+}

package/dist/cjs/modules/word/writers/comment-writer.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * DOCX Writers - Comments
+ *
+ * Renders word/comments.xml and word/commentsExtended.xml parts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderComments = renderComments;
+exports.renderCommentsExtended = renderCommentsExtended;
+const constants_1 = require("../constants");
+const paragraph_writer_1 = require("./paragraph-writer");
+const NS_W15 = "http://schemas.microsoft.com/office/word/2012/wordml";
+/** Render word/comments.xml. */
+function renderComments(xml, comments) {
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("w:comments", {
+        "xmlns:w": constants_1.NS_W,
+        "xmlns:r": constants_1.NS_R
+    });
+    for (const comment of comments) {
+        const attrs = {
+            "w:id": String(comment.id),
+            "w:author": comment.author
+        };
+        if (comment.date) {
+            attrs["w:date"] = comment.date;
+        }
+        if (comment.initials) {
+            attrs["w:initials"] = comment.initials;
+        }
+        xml.openNode("w:comment", attrs);
+        for (const para of comment.content) {
+            (0, paragraph_writer_1.renderParagraph)(xml, para);
+        }
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/**
+ * Render word/commentsExtended.xml — extended comment metadata (done/parentId).
+ * Only includes comments that have either `done` or `parentId` set.
+ * @returns true if any extended comments were rendered.
+ */
+function renderCommentsExtended(xml, comments) {
+    // Collect comments that need extension
+    const extended = comments.filter(c => c.done !== undefined || c.parentId !== undefined);
+    if (extended.length === 0) {
+        return false;
+    }
+    // Each extended comment must reference the paraId of its first paragraph
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("w15:commentsEx", {
+        "xmlns:w": constants_1.NS_W,
+        "xmlns:w15": NS_W15,
+        "mc:Ignorable": "w15",
+        "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006"
+    });
+    for (const c of extended) {
+        const firstPara = c.content[0];
+        if (!firstPara?.paraId) {
+            continue;
+        }
+        const attrs = { "w15:paraId": firstPara.paraId };
+        if (c.done) {
+            attrs["w15:done"] = "1";
+        }
+        if (c.parentId) {
+            attrs["w15:paraIdParent"] = c.parentId;
+        }
+        xml.leafNode("w15:commentEx", attrs);
+    }
+    xml.closeNode();
+    return true;
+}