@js-ak/excel-toolbox 1.8.3 → 1.9.0

package/build/esm/lib/workbook-builder/utils/build-workbook-rels-xml.js

@@ -0,0 +1,55 @@
+import { RELATIONSHIP_TYPES, XML_DECLARATION, XML_NAMESPACES } from "./constants.js";
+import { buildXml } from "./build-xml.js";
+/**
+ * Builds the `_rels/workbook.xml.rels` content for the given number of sheets.
+ *
+ * Relationships are created for each worksheet and then for styles, theme, and shared strings.
+ *
+ * @param sheetsCount - Number of worksheets in the workbook
+ * @returns XML string for the workbook relationships part
+ */
+export function buildWorkbookRels(sheetsCount) {
+    // Create relationships for each worksheet
+    const sheetRels = Array.from({ length: sheetsCount }, (_, i) => ({
+        attrs: {
+            Id: `rId${i + 1}`,
+            Target: `worksheets/sheet${i + 1}.xml`,
+            Type: RELATIONSHIP_TYPES.WORKSHEET,
+        },
+        tag: "Relationship",
+    }));
+    // Ids for styles, theme, and sharedStrings follow after the worksheets
+    const stylesRel = {
+        attrs: {
+            Id: `rId${sheetsCount + 1}`,
+            Target: "styles.xml",
+            Type: RELATIONSHIP_TYPES.STYLES,
+        },
+        tag: "Relationship",
+    };
+    const themeRel = {
+        attrs: {
+            Id: `rId${sheetsCount + 2}`,
+            Target: "theme/theme1.xml",
+            Type: RELATIONSHIP_TYPES.THEME,
+        },
+        tag: "Relationship",
+    };
+    const sharedStringsRel = {
+        attrs: {
+            Id: `rId${sheetsCount + 3}`,
+            Target: "sharedStrings.xml",
+            Type: RELATIONSHIP_TYPES.SHARED_STRINGS,
+        },
+        tag: "Relationship",
+    };
+    const allRels = [...sheetRels, stylesRel, themeRel, sharedStringsRel];
+    return [
+        XML_DECLARATION,
+        buildXml({
+            attrs: { xmlns: XML_NAMESPACES.PACKAGE_RELATIONSHIPS },
+            children: allRels,
+            tag: "Relationships",
+        }),
+    ].join("\n");
+}

package/build/esm/lib/workbook-builder/utils/build-workbook-xml.js

@@ -0,0 +1,23 @@
+import { XML_DECLARATION, XML_NAMESPACES } from "./constants.js";
+import { buildXml } from "./build-xml.js";
+export function buildWorkbookXml(sheets) {
+    return [
+        XML_DECLARATION,
+        buildXml({
+            attrs: {
+                xmlns: XML_NAMESPACES.SPREADSHEET_ML,
+                "xmlns:r": XML_NAMESPACES.OFFICE_DOCUMENT,
+            },
+            children: [
+                {
+                    children: sheets.map((sheet, i) => ({
+                        attrs: { name: sheet.name, "r:id": `rId${i + 1}`, sheetId: (i + 1).toString() },
+                        tag: "sheet",
+                    })),
+                    tag: "sheets",
+                },
+            ],
+            tag: "workbook",
+        }),
+    ].join("\n");
+}

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

@@ -0,0 +1,63 @@
+import { XML_DECLARATION, XML_NAMESPACES } from "./constants.js";
+import { buildCellChildren } from "./build-cell-children.js";
+import { buildXml } from "./build-xml.js";
+export function buildWorksheetXml(rows = new Map(), merges = []) {
+    const typeSetSkipping = new Set(["n"]);
+    const children = [
+        {
+            attrs: { ref: "A1:A1" },
+            tag: "dimension",
+        },
+        {
+            children: [{ attrs: { workbookViewId: "0" }, tag: "sheetView" }],
+            tag: "sheetViews",
+        },
+        {
+            attrs: { defaultRowHeight: "15" },
+            tag: "sheetFormatPr",
+        },
+        {
+            children: Array.from(rows.entries()).map(([rowNumber, row]) => ({
+                attrs: { r: rowNumber.toString() },
+                children: Array.from(row.cells.entries()).map(([colNumber, cell]) => {
+                    const cellRef = `${colNumber}${rowNumber}`;
+                    const attrT = (cell.type && typeSetSkipping.has(cell.type))
+                        ? undefined
+                        : cell.type;
+                    return {
+                        attrs: {
+                            r: cellRef,
+                            s: cell.style?.index,
+                            t: attrT,
+                        },
+                        children: buildCellChildren(cell),
+                        tag: "c",
+                    };
+                }),
+                tag: "row",
+            })),
+            tag: "sheetData",
+        },
+    ];
+    if (merges.length > 0) {
+        children.push({
+            attrs: { count: merges.length.toString() },
+            children: merges.map((ref) => ({
+                attrs: { ref },
+                tag: "mergeCell",
+            })),
+            tag: "mergeCells",
+        });
+    }
+    return [
+        XML_DECLARATION,
+        buildXml({
+            attrs: {
+                xmlns: XML_NAMESPACES.SPREADSHEET_ML,
+                "xmlns:r": XML_NAMESPACES.OFFICE_DOCUMENT,
+            },
+            children,
+            tag: "worksheet",
+        }),
+    ].join("\n");
+}

package/build/esm/lib/workbook-builder/utils/build-xml.js

@@ -0,0 +1,69 @@
+/**
+ * Builds XML string from an XmlNode structure.
+ *
+ * @param node - The XML node to convert to string
+ * @param level - The indentation level for formatting (default: 0)
+ *
+ * @returns The formatted XML string
+ */
+export function buildXml(node, level = 0) {
+    const { attrs = {}, children = [], tag } = node;
+    const attrStr = Object.entries(attrs)
+        .filter(attr => ((attr[1] !== undefined) && (attr[1] !== null)))
+        .map(([k, v]) => ` ${k}="${v}"`)
+        .join("");
+    const gap = "  ".repeat(level);
+    // No children → self-closing tag
+    if (!children.length) {
+        return `${gap}<${tag}${attrStr}/>`;
+    }
+    // Single text child → inline formatting
+    if (children.length === 1 && typeof children[0] === "string" && !children[0].includes("<")) {
+        return `${gap}<${tag}${attrStr}>${children[0].trimEnd()}</${tag}>`;
+    }
+    // Has children → recursive rendering
+    const inner = children
+        .map(c => typeof c === "string" ? `${"  ".repeat(level + 1)}${c.trimEnd()}` : buildXml(c, level + 1))
+        .join("\n");
+    return `${gap}<${tag}${attrStr}>\n${inner}\n${gap}</${tag}>`;
+}
+/**
+ * Cell XML Structure Documentation
+ *
+ * Reference: https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.cell?view=openxml-3.0.1
+ *
+ * Parent Elements:
+ * - row
+ *
+ * Child Elements:
+ * - extLst (Future Feature Data Storage Area)
+ * - f (Formula)
+ * - is (Rich Text Inline)
+ * - v (Cell Value)
+ *
+ * Attributes:
+ * - cm (Cell Metadata Index): The zero-based index of the cell metadata record associated with this cell.
+ *   Metadata information is found in the Metadata Part. Cell metadata is extra information stored at the
+ *   cell level, and is attached to the cell (travels through moves, copy / paste, clear, etc).
+ *   Cell metadata is not accessible via formula reference.
+ *   The possible values for this attribute are defined by the W3C XML Schema unsignedInt datatype.
+ *
+ * - ph (Show Phonetic): A Boolean value indicating if the spreadsheet application should show phonetic
+ *   information. Phonetic information is displayed in the same cell across the top of the cell and serves
+ *   as a 'hint' which indicates how the text should be pronounced. This should only be used for East Asian languages.
+ *   The possible values for this attribute are defined by the W3C XML Schema boolean datatype.
+ *
+ * - r (Reference): An A1 style reference to the location of this cell
+ *   The possible values for this attribute are defined by the ST_CellRef simple type.
+ *
+ * - s (Style Index): The index of this cell's style. Style records are stored in the Styles Part.
+ *   The possible values for this attribute are defined by the W3C XML Schema unsignedInt datatype.
+ *
+ * - t (Cell Data Type): An enumeration representing the cell's data type.
+ *   The possible values for this attribute are defined by the ST_CellType simple type.
+ *
+ * - vm (Value Metadata Index): The zero-based index of the value metadata record associated with this cell's value.
+ *   Metadata records are stored in the Metadata Part. Value metadata is extra information stored at the cell level,
+ *   but associated with the value rather than the cell itself. Value metadata is accessible via formula reference.
+ *   The possible values for this attribute are defined by the W3C XML Schema unsignedInt datatype.
+ */

package/build/esm/lib/workbook-builder/utils/constants.js

@@ -0,0 +1,52 @@
+// Content Types
+export const CONTENT_TYPES = {
+    APP: "application/vnd.openxmlformats-officedocument.extended-properties+xml",
+    CORE: "application/vnd.openxmlformats-package.core-properties+xml",
+    RELATIONSHIPS: "application/vnd.openxmlformats-package.relationships+xml",
+    SHARED_STRINGS: "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml",
+    STYLES: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml",
+    THEME: "application/vnd.openxmlformats-officedocument.theme+xml",
+    WORKBOOK: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
+    WORKSHEET: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml",
+    XML: "application/xml",
+};
+// Default file paths
+export const FILE_PATHS = {
+    APP: "docProps/app.xml",
+    CONTENT_TYPES: "[Content_Types].xml",
+    CORE: "docProps/core.xml",
+    RELS: "_rels/.rels",
+    SHARED_STRINGS: "xl/sharedStrings.xml",
+    STYLES: "xl/styles.xml",
+    THEME: "xl/theme/theme1.xml",
+    WORKBOOK: "xl/workbook.xml",
+    WORKBOOK_RELS: "xl/_rels/workbook.xml.rels",
+    WORKSHEET: "xl/worksheets/sheet1.xml",
+};
+// Relationship Types
+export const RELATIONSHIP_TYPES = {
+    APP: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
+    CORE: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
+    OFFICE_DOCUMENT: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+    SHARED_STRINGS: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings",
+    STYLES: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
+    THEME: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
+    WORKSHEET: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet",
+};
+// XML Declarations
+export const XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
+// XML Namespaces
+export const XML_NAMESPACES = {
+    CONTENT_TYPES: "http://schemas.openxmlformats.org/package/2006/content-types",
+    CORE_PROPERTIES: "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+    DC: "http://purl.org/dc/elements/1.1/",
+    DCMITYPE: "http://purl.org/dc/dcmitype/",
+    DCTERMS: "http://purl.org/dc/terms/",
+    DOC_PROPS_VTYPES: "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes",
+    DRAWINGML: "http://schemas.openxmlformats.org/drawingml/2006/main",
+    EXTENDED_PROPERTIES: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
+    OFFICE_DOCUMENT: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    PACKAGE_RELATIONSHIPS: "http://schemas.openxmlformats.org/package/2006/relationships",
+    SPREADSHEET_ML: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+    XSI: "http://www.w3.org/2001/XMLSchema-instance",
+};

package/build/esm/lib/workbook-builder/utils/date-to-excel-serial.js

@@ -0,0 +1,13 @@
+/**
+ * Converts a JavaScript Date object to Excel serial number format.
+ * Excel stores dates as serial numbers where 1 represents January 1, 1900.
+ *
+ * @param date - The JavaScript Date object to convert
+ *
+ * @returns The Excel serial number as a floating-point number
+ */
+export function dateToExcelSerial(date) {
+    const msPerDay = 24 * 60 * 60 * 1000;
+    const excelEpoch = Date.UTC(1899, 11, 30); // Excel "day 0"
+    return (date.getTime() - excelEpoch) / msPerDay;
+}

package/build/esm/lib/workbook-builder/utils/index.js

@@ -0,0 +1,18 @@
+export * from "./build-app-xml.js";
+export * from "./build-cell-children.js";
+export * from "./build-content-types-xml.js";
+export * from "./build-shared-strings-xml.js";
+export * from "./build-styles-xml.js";
+export * from "./build-theme-xml.js";
+export * from "./build-workbook-rels-xml.js";
+export * from "./build-workbook-xml.js";
+export * from "./build-worksheet-xml.js";
+export * from "./build-xml.js";
+export * from "./constants.js";
+export * from "./date-to-excel-serial.js";
+export * from "./initialize-files.js";
+export * from "./sheet.js";
+export * from "./write-shared-strings-xml.js";
+export * from "./write-styles-xml.js";
+export * from "./write-worksheet-xml.js";
+export * from "./write-xml.js";

package/build/esm/lib/workbook-builder/utils/initialize-files.js

@@ -0,0 +1,36 @@
+import { buildAppXml } from "./build-app-xml.js";
+import { buildContentTypesXml } from "./build-content-types-xml.js";
+import { buildCoreXml } from "./build-core-xml.js";
+import { buildRelsXml } from "./build-rels-xml.js";
+import { buildSharedStringsXml } from "./build-shared-strings-xml.js";
+import { buildStylesXml } from "./build-styles-xml.js";
+import { buildThemeXml } from "./build-theme-xml.js";
+import { buildWorkbookRels } from "./build-workbook-rels-xml.js";
+import { buildWorkbookXml } from "./build-workbook-xml.js";
+import { buildWorksheetXml } from "./build-worksheet-xml.js";
+import { FILE_PATHS } from "./constants.js";
+export const initializeFiles = (sheetName) => {
+    const sheetsCount = 1;
+    const contentTypesXml = buildContentTypesXml(sheetsCount);
+    const relsXml = buildRelsXml();
+    const appXml = buildAppXml({ sheetNames: [sheetName] });
+    const coreXml = buildCoreXml();
+    const workbookRelsXml = buildWorkbookRels(sheetsCount);
+    const stylesXml = buildStylesXml();
+    const sharedStringsXml = buildSharedStringsXml();
+    const themeXml = buildThemeXml();
+    const workbookXml = buildWorkbookXml([{ name: sheetName }]);
+    const worksheetXml = buildWorksheetXml();
+    return {
+        [FILE_PATHS.CONTENT_TYPES]: contentTypesXml,
+        [FILE_PATHS.RELS]: relsXml,
+        [FILE_PATHS.APP]: appXml,
+        [FILE_PATHS.CORE]: coreXml,
+        [FILE_PATHS.WORKBOOK_RELS]: workbookRelsXml,
+        [FILE_PATHS.STYLES]: stylesXml,
+        [FILE_PATHS.SHARED_STRINGS]: sharedStringsXml,
+        [FILE_PATHS.THEME]: themeXml,
+        [FILE_PATHS.WORKBOOK]: workbookXml,
+        [FILE_PATHS.WORKSHEET]: worksheetXml,
+    };
+};

package/build/esm/lib/workbook-builder/utils/sheet.js

@@ -0,0 +1,141 @@
+import { columnIndexToLetter, columnLetterToIndex } from "../../template/utils/index.js";
+import { dateToExcelSerial } from "./date-to-excel-serial.js";
+/** Maximum number of columns supported by Excel (XFD). */
+const MAX_COLUMNS = 16384;
+/** Maximum number of rows supported by Excel (1,048,576). */
+const MAX_ROWS = 1_048_576;
+/**
+ * Factory for creating a new sheet with bound helpers.
+ *
+ * @param name - Sheet name
+ * @param fn.addMerge - Function to add a merge range (bound to workbook)
+ * @param fn.removeMerge - Function to remove a merge range (bound to workbook)
+ * @param fn.addOrGetStyle - Function to add or get a style index
+ * @param fn.addSharedString - Function to add a shared string and return its index
+ * @returns SheetData instance with helpers
+ */
+export function createSheet(name, fn) {
+    const { addMerge, addOrGetStyle, addSharedString, removeMerge, } = fn;
+    const rows = new Map();
+    return {
+        name,
+        rows,
+        addMerge(mergeCell) {
+            return addMerge({ ...mergeCell, sheetName: name });
+        },
+        removeMerge(mergeCell) {
+            return removeMerge({ ...mergeCell, sheetName: name });
+        },
+        setCell(rowIndex, column, cell) {
+            if (rowIndex <= 0) {
+                throw new Error("Invalid rowIndex");
+            }
+            if (!Number.isInteger(rowIndex) || rowIndex <= 0) {
+                throw new Error("Invalid rowIndex: must be a positive integer");
+            }
+            if (rowIndex > MAX_ROWS) {
+                throw new Error(`Invalid rowIndex: exceeds Excel max rows (${MAX_ROWS})`);
+            }
+            if (!rows.has(rowIndex)) {
+                rows.set(rowIndex, { cells: new Map() });
+            }
+            const letterColumn = typeof column === "number"
+                ? columnIndexToLetter(column)
+                : column;
+            if (!isValidColumn(letterColumn)) {
+                throw new Error(`Invalid column string: "${letterColumn}"`);
+            }
+            // if is Date
+            if (cell.value instanceof Date) {
+                cell.value = dateToExcelSerial(cell.value);
+            }
+            if (cell.isFormula) {
+                cell.type = undefined;
+            }
+            else {
+                if (cell.type === "str") {
+                    throw new Error(`Cell type: "${cell.type}" valid only for formula cells`);
+                }
+                // If type is not provided — detect automatically
+                cell.type = detectCellType(cell.value, cell.type);
+            }
+            // Handle shared string
+            if (cell.type === "s") {
+                const idx = addSharedString(String(cell.value ?? ""), name);
+                cell = { ...cell, value: idx };
+            }
+            if (cell.style) {
+                const styleIndex = addOrGetStyle(cell.style, name);
+                cell.style.index = styleIndex;
+            }
+            rows.get(rowIndex)?.cells.set(letterColumn, cell);
+        },
+        getCell(rowIndex, column) {
+            if (typeof column === "number") {
+                if (column < 0 || column > MAX_COLUMNS) {
+                    throw new Error("Invalid column number");
+                }
+                return rows.get(rowIndex)?.cells.get(columnIndexToLetter(column));
+            }
+            else {
+                if (!isValidColumn(column)) {
+                    throw new Error(`Invalid column string: "${column}"`);
+                }
+                return rows.get(rowIndex)?.cells.get(column);
+            }
+        },
+        removeCell(rowIndex, column) {
+            if (rowIndex <= 0) {
+                throw new Error("Invalid rowIndex");
+            }
+            if (!Number.isInteger(rowIndex) || rowIndex <= 0) {
+                throw new Error("Invalid rowIndex: must be a positive integer");
+            }
+            if (rowIndex > MAX_ROWS) {
+                throw new Error(`Invalid rowIndex: exceeds Excel max rows (${MAX_ROWS})`);
+            }
+            const letterColumn = typeof column === "number"
+                ? columnIndexToLetter(column)
+                : column;
+            if (!isValidColumn(letterColumn)) {
+                throw new Error(`Invalid column string: "${letterColumn}"`);
+            }
+            return rows.get(rowIndex)?.cells.delete(letterColumn) ?? false;
+        },
+    };
+}
+/** Validates an Excel column string (A-Z, AA, ..., XFD). */
+function isValidColumn(column) {
+    if (!/^[A-Z]+$/.test(column))
+        return false;
+    const idx = columnLetterToIndex(column);
+    return idx > 0 && idx <= MAX_COLUMNS;
+}
+/**
+ * Detects the appropriate cell type based on the value when not explicitly specified.
+ *
+ * @param value - Cell value
+ * @param explicitType - Explicitly provided type, if any
+ * @returns CellType inferred or the explicit type
+ */
+function detectCellType(value, explicitType) {
+    if (explicitType) {
+        return explicitType;
+    }
+    if (value === null || value === undefined) {
+        // For empty cells we default to numeric type with empty value
+        return "n";
+    }
+    if (typeof value === "number") {
+        return "n";
+    }
+    if (typeof value === "boolean") {
+        return "b";
+    }
+    if (typeof value === "string") {
+        // Default to inlineStr for plain strings
+        return "inlineStr";
+    }
+    // Fallback to inlineStr
+    return "inlineStr";
+}

package/build/esm/lib/workbook-builder/utils/write-shared-strings-xml.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+import { escapeXml } from "../../utils/index.js";
+import { XML_DECLARATION, XML_NAMESPACES } from "./constants.js";
+/**
+ * Writes the `sharedStrings.xml` content to a file at the given destination.
+ *
+ * Uses a file write stream with backpressure control to avoid buffering large
+ * content in memory.
+ *
+ * @param destination - Absolute or relative file path to write
+ * @param strings - Array of unique strings used in the workbook
+ * @returns Promise that resolves when the write stream finishes
+ */
+export async function writeSharedStringsXml(destination, strings = []) {
+    // Ensure destination folder exists
+    await fsPromises.mkdir(path.dirname(destination), { recursive: true });
+    const stream = fs.createWriteStream(destination, { encoding: "utf-8" });
+    try {
+        // Document header
+        stream.write(XML_DECLARATION + "\n");
+        stream.write(`<sst xmlns="${XML_NAMESPACES.SPREADSHEET_ML}" count="${strings.length}" uniqueCount="${strings.length}">\n`);
+        // Main string items
+        for (const s of strings) {
+            const preserve = /^\s|\s$/.test(s) ? " xml:space=\"preserve\"" : "";
+            const siXml = `<si><t${preserve}>${escapeXml(s)}</t></si>\n`;
+            // Write with backpressure control
+            if (!stream.write(siXml)) {
+                await new Promise(resolve => stream.once("drain", () => resolve()));
+            }
+        }
+        // Closing tag
+        stream.write("</sst>");
+    }
+    finally {
+        stream.end();
+    }
+    return new Promise((resolve, reject) => {
+        stream.on("error", reject);
+        stream.on("finish", resolve);
+    });
+}

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

@@ -0,0 +1,157 @@
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+import * as Default from "../default/index.js";
+import { XML_DECLARATION, XML_NAMESPACES } from "./constants.js";
+import { writeXml } from "./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
+ */
+export async function writeStylesXml(destination, data) {
+    // Ensure destination folder exists
+    await fsPromises.mkdir(path.dirname(destination), { recursive: true });
+    const stream = fs.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(XML_DECLARATION + "\n");
+        await writeXml({
+            attrs: { xmlns: XML_NAMESPACES.SPREADSHEET_ML },
+            children,
+            tag: "styleSheet",
+        }, stream);
+    }
+    finally {
+        stream.end();
+    }
+    return new Promise((resolve, reject) => {
+        stream.on("error", reject);
+        stream.on("finish", resolve);
+    });
+}