@js-ak/excel-toolbox 1.8.3 → 1.9.0

package/build/cjs/lib/workbook-builder/utils/write-styles-xml.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeStylesXml = writeStylesXml;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const Default = __importStar(require("../default/index.js"));
+const constants_js_1 = require("./constants.js");
+const write_xml_js_1 = require("./write-xml.js");
+/**
+ * Writes the `styles.xml` part to a file at the given destination using a write stream.
+ * Falls back to default font/fill/border collections when none are provided.
+ *
+ * @param destination - Absolute or relative file path to write
+ * @param data - Style collections used to construct the stylesheet
+ * @param data.borders - Array of border XmlNodes
+ * @param data.cellXfs - Array of cell format records
+ * @param data.fills - Array of fill XmlNodes
+ * @param data.fonts - Array of font XmlNodes
+ * @param data.numFmts - Array of custom number formats (formatCode and id)
+ * @returns Promise that resolves when the write stream finishes
+ */
+async function writeStylesXml(destination, data) {
+    // Ensure destination folder exists
+    await promises_1.default.mkdir(node_path_1.default.dirname(destination), { recursive: true });
+    const stream = node_fs_1.default.createWriteStream(destination, { encoding: "utf-8" });
+    try {
+        const { borders = [], cellXfs = [], fills = [], fonts = [], numFmts = [], } = data || {};
+        const children = [];
+        if (numFmts.length) {
+            children.push({
+                attrs: { count: String(numFmts.length) },
+                children: numFmts.map(nf => ({
+                    attrs: {
+                        formatCode: nf.formatCode,
+                        numFmtId: String(nf.id),
+                    },
+                    tag: "numFmt",
+                })),
+                tag: "numFmts",
+            });
+        }
+        if (fonts.length) {
+            children.push({
+                attrs: { count: String(fonts.length) },
+                children: fonts,
+                tag: "fonts",
+            });
+        }
+        else {
+            children.push({
+                attrs: { count: "1" },
+                children: [Default.font()],
+                tag: "fonts",
+            });
+        }
+        if (fills.length) {
+            children.push({
+                attrs: { count: String(fills.length) },
+                children: fills,
+                tag: "fills",
+            });
+        }
+        else {
+            children.push({
+                attrs: { count: "1" },
+                children: [Default.fill()],
+                tag: "fills",
+            });
+        }
+        if (borders.length) {
+            children.push({
+                attrs: { count: String(borders.length) },
+                children: borders,
+                tag: "borders",
+            });
+        }
+        else {
+            children.push({
+                attrs: { count: "1" },
+                children: [Default.border()],
+                tag: "borders",
+            });
+        }
+        children.push({
+            attrs: { count: "1" },
+            children: [{
+                    attrs: { borderId: "0", fillId: "0", fontId: "0", numFmtId: "0" },
+                    tag: "xf",
+                }],
+            tag: "cellStyleXfs",
+        });
+        if (cellXfs.length) {
+            children.push({
+                attrs: { count: String(cellXfs.length) },
+                children: cellXfs.map((xf, i) => {
+                    const isBaseXf = i === 0;
+                    const hasAlignment = !!xf.alignment;
+                    const xfChildren = [];
+                    if (hasAlignment) {
+                        xfChildren.push({
+                            attrs: {
+                                ...(xf.alignment?.horizontal ? { horizontal: xf.alignment.horizontal } : {}),
+                                ...(xf.alignment?.vertical ? { vertical: xf.alignment.vertical } : {}),
+                                ...(xf.alignment?.wrapText ? { wrapText: "1" } : {}),
+                                ...(xf.alignment?.indent !== undefined ? { indent: String(xf.alignment.indent) } : {}),
+                            },
+                            tag: "alignment",
+                        });
+                    }
+                    return {
+                        attrs: {
+                            ...(isBaseXf
+                                ? {}
+                                : {
+                                    applyBorder: "1",
+                                    applyFill: "1",
+                                    applyFont: "1",
+                                    applyNumberFormat: xf.numFmtId ? "1" : "0",
+                                }),
+                            ...(hasAlignment ? { applyAlignment: "1" } : {}),
+                            borderId: String(xf.borderId),
+                            fillId: String(xf.fillId),
+                            fontId: String(xf.fontId),
+                            numFmtId: String(xf.numFmtId ?? 0),
+                            xfId: "0",
+                        },
+                        children: xfChildren,
+                        tag: "xf",
+                    };
+                }),
+                tag: "cellXfs",
+            });
+        }
+        else {
+            // Base style without fill
+            children.push({
+                attrs: { count: "1" },
+                children: [
+                    { attrs: { borderId: "0", fillId: "0", fontId: "0", numFmtId: "0", xfId: "0" }, tag: "xf" },
+                ],
+                tag: "cellXfs",
+            });
+        }
+        // XML declaration
+        stream.write(constants_js_1.XML_DECLARATION + "\n");
+        await (0, write_xml_js_1.writeXml)({
+            attrs: { xmlns: constants_js_1.XML_NAMESPACES.SPREADSHEET_ML },
+            children,
+            tag: "styleSheet",
+        }, stream);
+    }
+    finally {
+        stream.end();
+    }
+    return new Promise((resolve, reject) => {
+        stream.on("error", reject);
+        stream.on("finish", resolve);
+    });
+}

package/build/cjs/lib/workbook-builder/utils/write-worksheet-xml.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeWorksheetXml = writeWorksheetXml;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const constants_js_1 = require("./constants.js");
+const column_index_to_letter_js_1 = require("../../template/utils/column-index-to-letter.js");
+const column_letter_to_index_js_1 = require("../../template/utils/column-letter-to-index.js");
+/**
+ * Writes a worksheet XML file to the given destination using a streaming approach.
+ *
+ * - Streams rows and cells to minimize memory usage
+ * - Tracks the worksheet dimension (min/max rows/cols) while streaming
+ * - Updates the <dimension> ref at the end by rewriting the file in a buffered pass
+ *
+ * @param destination - Absolute or relative file path for the worksheet XML
+ * @param rows - Map of rowIndex -> RowData with cells
+ * @param merges - Merge ranges to append after <sheetData>
+ * @returns Promise that resolves when the file is fully written and dimension updated
+ */
+async function writeWorksheetXml(destination, rows = new Map(), merges = []) {
+    // ensure folder exists
+    await promises_1.default.mkdir(node_path_1.default.dirname(destination), { recursive: true });
+    const stream = node_fs_1.default.createWriteStream(destination, { encoding: "utf-8" });
+    // Track dimension incrementally while streaming
+    let minRow = Number.POSITIVE_INFINITY;
+    let maxRow = 0;
+    let minCol = Number.POSITIVE_INFINITY;
+    let maxCol = 0;
+    try {
+        // header
+        stream.write(constants_js_1.XML_DECLARATION + "\n");
+        stream.write(`<worksheet xmlns="${constants_js_1.XML_NAMESPACES.SPREADSHEET_ML}" xmlns:r="${constants_js_1.XML_NAMESPACES.OFFICE_DOCUMENT}">\n`);
+        // dimension
+        stream.write("  <dimension ref=\"A1:A1\"/>\n");
+        // sheetViews
+        stream.write("  <sheetViews>\n");
+        stream.write("    <sheetView workbookViewId=\"0\"/>\n");
+        stream.write("  </sheetViews>\n");
+        // sheetFormatPr
+        stream.write("  <sheetFormatPr defaultRowHeight=\"15\"/>\n");
+        // sheetData start
+        stream.write("  <sheetData>\n");
+        // rows (stream, without accumulation)
+        const typeSetSkipping = new Set(["n"]);
+        let processedRows = 0;
+        for (const [rowNumber, row] of rows) {
+            if (row.cells.size > 0) {
+                if (rowNumber < minRow)
+                    minRow = rowNumber;
+                if (rowNumber > maxRow)
+                    maxRow = rowNumber;
+            }
+            // Build the row string
+            const rowStart = `    <row r="${rowNumber}">\n`;
+            const rowEnd = "    </row>\n";
+            // write to stream with backpressure control
+            if (!stream.write(rowStart)) {
+                await new Promise(resolve => stream.once("drain", () => resolve()));
+            }
+            // if you need to stream cells, you can do so as well:
+            for (const [colNumber, cellData] of row.cells) {
+                const colIndex = (0, column_letter_to_index_js_1.columnLetterToIndex)(colNumber) - 1;
+                if (colIndex < minCol)
+                    minCol = colIndex;
+                if (colIndex > maxCol)
+                    maxCol = colIndex;
+                const attrT = cellData.type && typeSetSkipping.has(cellData.type)
+                    ? ""
+                    : ` t="${cellData.type}"`;
+                const attrS = cellData.style?.index
+                    ? ` s="${cellData.style?.index}"`
+                    : "";
+                let cellXml = "";
+                if (cellData.isFormula) {
+                    cellXml = `      <c r="${colNumber}${rowNumber}"${attrS}${attrT}><f>${cellData.value}</f></c>\n`;
+                }
+                else {
+                    switch (cellData.type) {
+                        case "b": {
+                            cellXml = `      <c r="${colNumber}${rowNumber}"${attrS}${attrT}><v>${cellData.value ? "1" : "0"}</v></c>\n`;
+                            break;
+                        }
+                        case "inlineStr": {
+                            cellXml = `      <c r="${colNumber}${rowNumber}"${attrS}${attrT}><is><t>${cellData.value}</t></is></c>\n`;
+                            break;
+                        }
+                        default: {
+                            cellXml = `      <c r="${colNumber}${rowNumber}"${attrS}${attrT}><v>${cellData.value}</v></c>\n`;
+                            break;
+                        }
+                    }
+                }
+                stream.write(cellXml);
+                // if (!stream.write(cellXml)) {
+                // 	await new Promise<void>(resolve => stream.once("drain", () => resolve()));
+                // }
+            }
+            if (!stream.write(rowEnd)) {
+                await new Promise(resolve => stream.once("drain", () => resolve()));
+            }
+            // Unload the event loop every 100 rows
+            processedRows++;
+            if (processedRows % 100 === 0) {
+                await new Promise(resolve => setImmediate(resolve));
+            }
+            // Unload the event loop every 100 rows
+            // rows.delete(rowNumber);
+        }
+        // sheetData end
+        stream.write("  </sheetData>\n");
+        // mergeCells
+        if (merges.length > 0) {
+            stream.write(`  <mergeCells count="${merges.length}">\n`);
+            for (const merge of merges) {
+                if (merge.startCol < minCol)
+                    minCol = merge.startCol;
+                if (merge.endCol > maxCol)
+                    maxCol = merge.endCol;
+                if (merge.startRow < minRow)
+                    minRow = merge.startRow;
+                if (merge.endRow > maxRow)
+                    maxRow = merge.endRow;
+                const ref = `${(0, column_index_to_letter_js_1.columnIndexToLetter)(merge.startCol)}${merge.startRow}:${(0, column_index_to_letter_js_1.columnIndexToLetter)(merge.endCol)}${merge.endRow}`;
+                stream.write(`    <mergeCell ref="${ref}"/>\n`);
+            }
+            stream.write("  </mergeCells>\n");
+        }
+        // close worksheet
+        stream.write("</worksheet>\n");
+    }
+    finally {
+        stream.end();
+    }
+    let finalDimensionRef = "A1:A1";
+    if (Number.isFinite(minCol) && Number.isFinite(minRow) && maxCol >= 0 && maxRow > 0) {
+        finalDimensionRef = `${(0, column_index_to_letter_js_1.columnIndexToLetter)(minCol)}${minRow}:${(0, column_index_to_letter_js_1.columnIndexToLetter)(maxCol)}${maxRow}`;
+    }
+    await new Promise((resolve, reject) => {
+        stream.on("error", reject);
+        stream.on("finish", resolve);
+    });
+    await updateWorksheetDimensionInFile(destination, finalDimensionRef);
+    return;
+}
+// async function updateWorksheetDimensionInFile(destination: string, dimensionRef: string): Promise<void> {
+// 	const tempPath = `${destination}.tmp`;
+// 	const readStream = fs.createReadStream(destination, { encoding: "utf-8" });
+// 	const rl = readline.createInterface({ crlfDelay: Infinity, input: readStream });
+// 	const writeStream = fs.createWriteStream(tempPath, { encoding: "utf-8" });
+// 	let updated = false;
+// 	const rlClosed = new Promise<void>(resolve => rl.once("close", resolve));
+// 	for await (const line of rl) {
+// 		let outLine = line;
+// 		if (!updated && line.includes("<dimension")) {
+// 			outLine = line.replace(/(<dimension[^>]*ref=")[^"]*("[^>]*\/>)/, `$1${dimensionRef}$2`);
+// 			updated = true;
+// 		}
+// 		if (!writeStream.write(outLine + "\n")) {
+// 			await new Promise<void>(resolve => writeStream.once("drain", resolve));
+// 		}
+// 	}
+// 	await rlClosed;
+// 	writeStream.end();
+// 	await new Promise<void>(resolve => writeStream.once("finish", resolve));
+// 	await fsPromises.rename(tempPath, destination);
+// }
+/**
+ * Updates the <dimension> ref attribute in an existing worksheet XML file.
+ * Performs a buffered line-by-line rewrite to a temporary file, then renames it in place.
+ *
+ * @param destination - Path to the worksheet XML file to update
+ * @param dimensionRef - Final dimension reference, e.g., "A1:C25"
+ */
+async function updateWorksheetDimensionInFile(destination, dimensionRef) {
+    const tempPath = `${destination}.tmp`;
+    const readStream = node_fs_1.default.createReadStream(destination, { encoding: "utf-8" });
+    const rl = node_readline_1.default.createInterface({ crlfDelay: Infinity, input: readStream });
+    const writeStream = node_fs_1.default.createWriteStream(tempPath, { encoding: "utf-8" });
+    let updated = false;
+    let buffer = "";
+    const BUFFER_SIZE = 64 * 1024; // 64 KB
+    for await (const line of rl) {
+        let outLine = line;
+        if (!updated && line.includes("<dimension")) {
+            outLine = line.replace(/(<dimension[^>]*ref=")[^"]*("[^>]*\/>)/, `$1${dimensionRef}$2`);
+            updated = true;
+        }
+        buffer += outLine + "\n";
+        if (buffer.length >= BUFFER_SIZE) {
+            if (!writeStream.write(buffer)) {
+                await new Promise(resolve => writeStream.once("drain", resolve));
+            }
+            buffer = "";
+        }
+    }
+    // Write remaining buffer
+    if (buffer)
+        writeStream.write(buffer);
+    // Close streams
+    await new Promise(resolve => writeStream.end(resolve));
+    // Replace original file
+    await promises_1.default.rename(tempPath, destination);
+}

package/build/cjs/lib/workbook-builder/utils/write-xml.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeXml = writeXml;
+async function writeXml(node, stream, level = 0, chunkSize = 100) {
+    const { attrs = {}, children = [], tag } = node;
+    const attrStr = Object.entries(attrs)
+        .filter(([, v]) => v !== undefined && v !== null)
+        .map(([k, v]) => ` ${k}="${v}"`)
+        .join("");
+    const gap = "  ".repeat(level);
+    // No children → self-closing tag
+    if (!children.length) {
+        stream.write(`${gap}<${tag}${attrStr}/>\n`);
+        return;
+    }
+    // Single text child → inline formatting
+    if (children.length === 1 && typeof children[0] === "string" && !children[0].includes("<")) {
+        stream.write(`${gap}<${tag}${attrStr}>${children[0]}</${tag}>\n`);
+        return;
+    }
+    // Has children → recursive streaming
+    stream.write(`${gap}<${tag}${attrStr}>\n`);
+    let processed = 0;
+    for (const c of children) {
+        if (typeof c === "string") {
+            stream.write(`${"  ".repeat(level + 1)}${c}\n`);
+        }
+        else {
+            await writeXml(c, stream, level + 1, chunkSize);
+        }
+        processed++;
+        if (processed % chunkSize === 0) {
+            await new Promise(resolve => setImmediate(resolve));
+        }
+    }
+    stream.write(`${gap}</${tag}>\n`);
+}