@js-ak/excel-toolbox 1.8.2 → 1.9.0

package/build/cjs/lib/workbook-builder/workbook-builder.js

@@ -0,0 +1,414 @@
+"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.WorkbookBuilder = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const Zip = __importStar(require("../zip/index.js"));
+const index_js_1 = require("../template/utils/index.js");
+const Utils = __importStar(require("./utils/index.js"));
+const Default = __importStar(require("./default/index.js"));
+const MergeCells = __importStar(require("./merge-cells/index.js"));
+const SharedStringRef = __importStar(require("./shared-string-ref/index.js"));
+const StyleRef = __importStar(require("./style-ref/index.js"));
+/**
+ * Builds Excel workbooks by composing sheets, styles, shared strings and merges,
+ * and provides methods to save to file or stream.
+ *
+ * @experimental This API is experimental and might change in future versions.
+ */
+class WorkbookBuilder {
+    /** In-memory representation of workbook files to be zipped. */
+    #files;
+    /** Collection of sheets keyed by sheet name. */
+    #sheets = new Map();
+    /** Shared strings storage used by cells of type "s". */
+    #sharedStrings = [];
+    /** Map for lookup of shared string indices (key = string, value = index). */
+    #sharedStringMap = new Map();
+    /** Workbook style collections. */
+    #borders;
+    #cellXfs;
+    #fills;
+    #fonts;
+    #numFmts;
+    /** Map of serialized style JSON to style index (xf). */
+    #styleMap = new Map();
+    /** Map caches for fast de-duplication of style components. */
+    #fontMap = new Map();
+    #fillMap = new Map();
+    #borderMap = new Map();
+    /** Merge cell ranges grouped by sheet name. */
+    #mergeCells = new Map();
+    /**
+     * Creates a new workbook with a default sheet and initial style collections.
+     *
+     * @param options.defaultSheetName - The name for the initial sheet
+     */
+    constructor({ defaultSheetName = Default.sheetName(), } = {}) {
+        this.#files = Utils.initializeFiles(defaultSheetName);
+        // Initialize base style collections
+        this.#borders = [Default.border()];
+        this.#fills = [Default.fill()];
+        this.#fonts = [Default.font()];
+        this.#numFmts = [];
+        this.#cellXfs = [Default.cellXf()];
+        // Seed component maps with defaults at index 0
+        this.#fontMap.set(JSON.stringify(this.#fonts[0]), 0);
+        this.#fillMap.set(JSON.stringify(this.#fills[0]), 0);
+        this.#borderMap.set(JSON.stringify(this.#borders[0]), 0);
+        const sheet = Utils.createSheet(defaultSheetName, {
+            addMerge: this.#addMerge.bind(this),
+            addOrGetStyle: this.#addOrGetStyle.bind(this),
+            addSharedString: this.#addSharedString.bind(this),
+            removeMerge: this.#removeMerge.bind(this),
+        });
+        this.#sheets.set(Default.sheetName(), sheet);
+    }
+    /** Returns the internal sheets map. */
+    get sheets() {
+        return this.#sheets;
+    }
+    /** Returns the shared strings array. */
+    get sharedStrings() {
+        return this.#sharedStrings;
+    }
+    /** Replaces the shared strings array. */
+    set sharedStrings(sharedStrings) {
+        this.#sharedStrings = sharedStrings;
+    }
+    /** Returns the shared string index map. */
+    get sharedStringMap() {
+        return this.#sharedStringMap;
+    }
+    /** Returns the borders collection. */
+    get borders() {
+        return this.#borders;
+    }
+    /** Returns the border cache map (serialized xml -> index). */
+    get bordersMap() {
+        return this.#borderMap;
+    }
+    /** Returns the cellXfs (style records). */
+    get cellXfs() {
+        return this.#cellXfs;
+    }
+    /** Returns the fills collection. */
+    get fills() {
+        return this.#fills;
+    }
+    /** Returns the fill cache map (serialized xml -> index). */
+    get fillsMap() {
+        return this.#fillMap;
+    }
+    /** Returns the fonts collection. */
+    get fonts() {
+        return this.#fonts;
+    }
+    /** Returns the font cache map (serialized xml -> index). */
+    get fontsMap() {
+        return this.#fontMap;
+    }
+    /** Returns the number formats collection. */
+    get numFmts() {
+        return this.#numFmts;
+    }
+    /** Returns the mapping from serialized style JSON to style index. */
+    get styleMap() {
+        return this.#styleMap;
+    }
+    /** Returns the merge ranges, grouped by sheet name. */
+    get mergeCells() {
+        return this.#mergeCells;
+    }
+    /** Shared strings */
+    /** Adds a shared string (or returns existing index) and tracks its usage by sheet. */
+    #addSharedString(str, sheetName) {
+        return SharedStringRef.add.bind(this)({ sheetName, str });
+    }
+    /** -------------- */
+    /** Style refs */
+    /** Adds a style or returns an existing style index. */
+    #addOrGetStyle(style) {
+        return StyleRef.addOrGet.bind(this)({ style });
+    }
+    ;
+    /** ---------- */
+    /** Merge cells */
+    /** Adds a merge range to a sheet. */
+    #addMerge(payload) {
+        return MergeCells.add.bind(this)(payload);
+    }
+    /** Removes a merge range from a sheet. */
+    #removeMerge(payload) {
+        return MergeCells.remove.bind(this)(payload);
+    }
+    /** Removes all merge ranges for a sheet. */
+    #removeSheetMerges(sheetName) {
+        this.mergeCells.delete(sheetName);
+    }
+    /** ----------- */
+    /** Adds or replaces a logical file content in the in-memory file map. */
+    #addFile(key, value) {
+        this.#files[key] = value;
+    }
+    /** Updates the docProps/app.xml content based on current sheet names. */
+    #updateAppXml() {
+        this.#addFile(Utils.FILE_PATHS.APP, Utils.buildAppXml({ sheetNames: Array.from(this.#sheets.keys()) }));
+    }
+    /** Updates the xl/workbook.xml content based on current sheets. */
+    #updateWorkbookXml() {
+        this.#addFile(Utils.FILE_PATHS.WORKBOOK, Utils.buildWorkbookXml(Array.from(this.#sheets.values())));
+    }
+    /** Updates the xl/_rels/workbook.xml.rels relationships for sheets. */
+    #updateWorkbookRels() {
+        this.#addFile(Utils.FILE_PATHS.WORKBOOK_RELS, Utils.buildWorkbookRels(this.#sheets.size));
+    }
+    /** Updates [Content_Types].xml with sheet overrides. */
+    #updateContentTypes() {
+        this.#addFile(Utils.FILE_PATHS.CONTENT_TYPES, Utils.buildContentTypesXml(this.#sheets.size));
+    }
+    /** Public methods */
+    /**
+     * Adds a new sheet to the workbook.
+     *
+     * @throws Error if a sheet with the same name already exists
+     * @param sheetName - Sheet name to add
+     * @returns The created sheet data
+     */
+    addSheet(sheetName) {
+        if (this.getSheet(sheetName)) {
+            throw new Error("Sheet with this name already exists");
+        }
+        const sheet = Utils.createSheet(sheetName, {
+            addMerge: this.#addMerge.bind(this),
+            addOrGetStyle: this.#addOrGetStyle.bind(this),
+            addSharedString: this.#addSharedString.bind(this),
+            removeMerge: this.#removeMerge.bind(this),
+        });
+        this.#sheets.set(sheetName, sheet);
+        // Add entry to app.xml
+        this.#updateAppXml();
+        // Add entry to workbook.xml
+        this.#updateWorkbookXml();
+        // Add relationship in workbook.xml.rels
+        this.#updateWorkbookRels();
+        // Add Override in [Content_Types].xml
+        this.#updateContentTypes();
+        return sheet;
+    }
+    /** Returns a sheet by name if it exists. */
+    getSheet(sheetName) {
+        return this.#sheets.get(sheetName);
+    }
+    /**
+     * Removes a sheet by name.
+     * If cleanup is enabled, also removes associated shared strings and styles.
+     *
+     * @param sheetName - Sheet name to remove
+     * @returns True if the sheet existed and was removed
+     */
+    removeSheet(sheetName) {
+        const sheet = this.#sheets.get(sheetName);
+        if (!sheet) {
+            throw new Error("Sheet not found: " + sheetName);
+        }
+        // Remove its merges
+        this.#removeSheetMerges(sheetName);
+        // Remove from collection
+        this.#sheets.delete(sheetName);
+        this.#updateAppXml();
+        this.#updateWorkbookXml();
+        this.#updateWorkbookRels();
+        this.#updateContentTypes();
+        return true;
+    }
+    /**
+     * Returns a snapshot of the workbook internals for inspection and tests.
+     * The returned structure is deeply frozen to avoid accidental mutations.
+     */
+    getInfo() {
+        function deepFreeze(obj) {
+            if (obj === null || obj === undefined) {
+                return obj;
+            }
+            if (typeof obj !== "object") {
+                // string | number | boolean | symbol
+                return obj;
+            }
+            if (Array.isArray(obj)) {
+                return Object.freeze(obj.map(item => deepFreeze(item)));
+            }
+            if (obj instanceof Map) {
+                const frozenMap = new Map(Array.from(obj.entries()).map(([k, v]) => [k, deepFreeze(v)]));
+                return Object.freeze(frozenMap);
+            }
+            if (obj instanceof Set) {
+                const frozenSet = new Set(Array.from(obj.values()).map(v => deepFreeze(v)));
+                return Object.freeze(frozenSet);
+            }
+            // XmlNode or generic object
+            const frozenObj = {};
+            for (const [k, v] of Object.entries(obj)) {
+                frozenObj[k] = deepFreeze(v);
+            }
+            return Object.freeze(frozenObj);
+        }
+        return deepFreeze({
+            mergeCells: new Map(this.#mergeCells),
+            sheetsNames: Array.from(this.#sheets.values()).map((sheet) => sheet.name),
+            sharedStringMap: new Map(this.#sharedStringMap),
+            sharedStrings: [...this.#sharedStrings],
+            styles: {
+                borders: [...this.#borders],
+                cellXfs: [...this.#cellXfs],
+                fills: [...this.#fills],
+                fonts: [...this.#fonts],
+                numFmts: [...this.#numFmts],
+                styleMap: new Map(this.#styleMap),
+            },
+        });
+    }
+    /**
+     * Generates workbook XML parts in-memory and writes a .xlsx zip to disk.
+     *
+     * @param path - Absolute or relative file path to write
+     */
+    async saveToFile(path) {
+        let index = 0;
+        for (const sheet of this.#sheets.values()) {
+            const merges = this.#mergeCells.get(sheet.name) || [];
+            const preparedMerges = merges.map(merge => `${(0, index_js_1.columnIndexToLetter)(merge.startCol)}${merge.startRow}:${(0, index_js_1.columnIndexToLetter)(merge.endCol)}${merge.endRow}`);
+            const xml = Utils.buildWorksheetXml(sheet.rows, preparedMerges);
+            const filePath = `xl/worksheets/sheet${++index}.xml`;
+            this.#addFile(filePath, (0, index_js_1.updateDimension)(xml));
+        }
+        if (this.#sharedStrings.length) {
+            const xml = Utils.buildSharedStringsXml(this.#sharedStrings);
+            this.#addFile(Utils.FILE_PATHS.SHARED_STRINGS, xml);
+        }
+        // Styles
+        this.#addFile(Utils.FILE_PATHS.STYLES, Utils.buildStylesXml({
+            borders: this.#borders,
+            cellXfs: this.#cellXfs,
+            fills: this.#fills,
+            fonts: this.#fonts,
+            numFmts: this.#numFmts,
+        }));
+        const zipBuffer = await Zip.create(this.#files);
+        await promises_1.default.writeFile(path, zipBuffer);
+    }
+    /**
+     * Saves the workbook to a writable stream using temporary files.
+     * This method creates temporary files from the in-memory data and streams them
+     * to the output stream, avoiding loading the entire file into memory.
+     *
+     * @param output - Writable stream to receive the Excel file
+     * @param options.destination - Optional existing directory to use instead of a system temp directory
+     * @param options.cleanup - Optional flag to cleanup the temporary directory after saving (default: true)
+     * @returns Promise that resolves when the file has been fully written
+     */
+    async saveToStream(output, options) {
+        const { cleanup = true, destination } = options ?? {};
+        // Determine a temp directory to assemble ZIP contents
+        let tempDir = "";
+        if (destination) {
+            // Create a random subdirectory inside provided destination
+            tempDir = node_path_1.default.join(destination, node_crypto_1.default.randomUUID());
+            await promises_1.default.mkdir(tempDir, { recursive: true });
+        }
+        else {
+            // Create a temp directory in OS temp
+            tempDir = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), "excel-toolbox-", node_crypto_1.default.randomUUID()));
+        }
+        let index = 0;
+        const usedFileKeys = [];
+        // Write "xl/worksheets/sheet*.xml"
+        for (const sheet of this.#sheets.values()) {
+            const merges = this.#mergeCells.get(sheet.name) || [];
+            const filePath = `xl/worksheets/sheet${++index}.xml`;
+            usedFileKeys.push(filePath);
+            const fullPath = node_path_1.default.join(tempDir, ...filePath.split("/"));
+            await Utils.writeWorksheetXml(fullPath, sheet.rows, merges);
+            this.#addFile(filePath, "");
+        }
+        // Write "xl/sharedStrings.xml"
+        if (this.#sharedStrings.length) {
+            usedFileKeys.push(Utils.FILE_PATHS.SHARED_STRINGS);
+            const fullPath = node_path_1.default.join(tempDir, ...Utils.FILE_PATHS.SHARED_STRINGS.split("/"));
+            await Utils.writeSharedStringsXml(fullPath, this.#sharedStrings);
+        }
+        // Write "xl/styles.xml"
+        {
+            usedFileKeys.push(Utils.FILE_PATHS.STYLES);
+            const fullPath = node_path_1.default.join(tempDir, ...Utils.FILE_PATHS.STYLES.split("/"));
+            await Utils.writeStylesXml(fullPath, {
+                borders: this.#borders,
+                cellXfs: this.#cellXfs,
+                fills: this.#fills,
+                fonts: this.#fonts,
+                numFmts: this.#numFmts,
+            });
+        }
+        try {
+            // Write all files from memory to temporary files
+            const fileKeys = [];
+            for (const [key, value] of Object.entries(this.#files)) {
+                if (usedFileKeys.includes(key)) {
+                    fileKeys.push(key);
+                    continue;
+                }
+                const fullPath = node_path_1.default.join(tempDir, ...key.split("/"));
+                await promises_1.default.mkdir(node_path_1.default.dirname(fullPath), { recursive: true });
+                await promises_1.default.writeFile(fullPath, value);
+                fileKeys.push(key);
+            }
+            // Create ZIP archive and stream to output
+            await Zip.createWithStream(fileKeys, tempDir, output);
+        }
+        finally {
+            // Clean up temporary files
+            if (cleanup) {
+                await promises_1.default.rm(tempDir, { force: true, recursive: true });
+            }
+        }
+    }
+}
+exports.WorkbookBuilder = WorkbookBuilder;

package/build/cjs/lib/zip/utils/to-bytes.js

@@ -17,21 +17,29 @@ const node_buffer_1 = require("node:buffer");
  * @returns {Buffer} - A new Buffer of exactly `len` bytes containing:
  *        1. The value's bytes in little-endian order (least significant byte first)
  *        2. Zero padding in any remaining higher-order bytes
- * @throws {RangeError} - If the value requires more bytes than `len` to represent
- *        (though this is currently not explicitly checked)
+ *
+ * @throws {RangeError} - If the length is not positive or the value is negative.
  */
 function toBytes(value, len) {
-    // Allocate a new Buffer of the requested length, automatically zero-filled
+    if (len <= 0)
+        throw new RangeError("Length must be a positive integer");
+    if (value < 0)
+        throw new RangeError("Negative values are not supported");
+    if (!Number.isSafeInteger(value))
+        throw new RangeError("Value must be a safe integer");
+    // Use BigInt to correctly handle 53-bit values
+    let bigint = BigInt(value);
     const buf = node_buffer_1.Buffer.alloc(len);
-    // Process each byte position from least significant to most significant
     for (let i = 0; i < len; i++) {
-        // Store the least significant byte of the current value
-        buf[i] = value & 0xff; // Mask to get bottom 8 bits
-        // Right-shift the value by 8 bits to process the next byte
-        // Note: This uses unsigned right shift (>>> would be signed)
-        value >>= 8;
-        // If the loop completes with value != 0, we've overflowed the buffer length,
-        // but this isn't currently checked/handled
+        // Extract the least significant byte and assign to buffer
+        buf[i] = Number(bigint & 0xffn);
+        bigint >>= 8n;
+        // Stop early if all remaining bits are zero
+        if (bigint === 0n)
+            break;
     }
+    // If bigint is still non-zero, it means we overflowed the buffer length
+    if (bigint > 0n)
+        throw new RangeError("Value exceeds the maximum size for the specified length");
     return buf;
 }

package/build/esm/lib/template/template-fs.js

@@ -3,6 +3,7 @@ import * as fsSync from "node:fs";
 import * as path from "node:path";
 import * as readline from "node:readline";
 import crypto from "node:crypto";
+import * as SharedUtils from "../utils/index.js";
 import * as Xml from "../xml/index.js";
 import * as Zip from "../zip/index.js";
 import * as Utils from "./utils/index.js";
@@ -445,7 +446,7 @@ export class TemplateFs {
                 const cellTags = Object.entries(cells).map(([col, value]) => {
                     const colUpper = col.toUpperCase();
                     const ref = `${colUpper}${rowNumber}`;
-                    return `<c r="${ref}" t="inlineStr"><is><t>${Utils.escapeXml(value)}</t></is></c>`;
+                    return `<c r="${ref}" t="inlineStr"><is><t>${SharedUtils.escapeXml(value)}</t></is></c>`;
                 }).join("");
                 return `<row r="${rowNumber}">${cellTags}</row>`;
             }).join("");

package/build/esm/lib/template/template-memory.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs/promises";
+import * as SharedUtils from "../utils/index.js";
 import * as Xml from "../xml/index.js";
 import * as Zip from "../zip/index.js";
 import * as Utils from "./utils/index.js";
@@ -497,7 +498,7 @@ export class TemplateMemory {
                 const cellTags = Object.entries(cells).map(([col, value]) => {
                     const colUpper = col.toUpperCase();
                     const ref = `${colUpper}${rowNumber}`;
-                    return `<c r="${ref}" t="inlineStr"><is><t>${Utils.escapeXml(value)}</t></is></c>`;
+                    return `<c r="${ref}" t="inlineStr"><is><t>${SharedUtils.escapeXml(value)}</t></is></c>`;
                 }).join("");
                 return `<row r="${rowNumber}">${cellTags}</row>`;
             }).join("");

package/build/esm/lib/template/utils/column-letter-to-index.js

@@ -0,0 +1,12 @@
+export function columnLetterToIndex(col) {
+    if (!col)
+        return -1;
+    let index = 0;
+    for (let i = 0; i < col.length; i++) {
+        const charCode = col.charCodeAt(i);
+        if (charCode < 65 || charCode > 90)
+            return -1; // не A-Z
+        index = index * 26 + (charCode - 64); // 'A' -> 1
+    }
+    return index;
+}

package/build/esm/lib/template/utils/index.js

@@ -4,8 +4,8 @@ export * from "./check-row.js";
 export * from "./check-rows.js";
 export * from "./check-start-row.js";
 export * from "./column-index-to-letter.js";
+export * from "./column-letter-to-index.js";
 export * from "./compare-columns.js";
-export * from "./escape-xml.js";
 export * from "./extract-xml-declaration.js";
 export * from "./found-arrays-in-replacements.js";
 export * from "./get-by-path.js";

package/build/esm/lib/template/utils/prepare-row-to-cells.js

@@ -1,5 +1,5 @@
+import { escapeXml } from "../../utils/index.js";
 import { columnIndexToLetter } from "./column-index-to-letter.js";
-import { escapeXml } from "./escape-xml.js";
 export function prepareRowToCells(row, rowNumber) {
     return row.map((value, colIndex) => {
         const colLetter = columnIndexToLetter(colIndex);

package/build/esm/lib/template/utils/validate-worksheet-xml.js

@@ -30,7 +30,7 @@ export function validateWorksheetXml(xml) {
     const requiredElements = [
         { name: "sheetViews", tag: "<sheetViews>" },
         { name: "sheetFormatPr", tag: "<sheetFormatPr" },
-        { name: "sheetData", tag: "<sheetData>" },
+        { name: "sheetData", tag: "<sheetData" },
     ];
     for (const { name, tag } of requiredElements) {
         if (!xml.includes(tag)) {
@@ -38,16 +38,26 @@ export function validateWorksheetXml(xml) {
         }
     }
     // 3. Extract and validate sheetData
-    const sheetDataStart = xml.indexOf("<sheetData>");
-    const sheetDataEnd = xml.indexOf("</sheetData>");
-    if (sheetDataStart === -1 || sheetDataEnd === -1) {
-        return createError("Invalid sheetData structure");
+    // 3. Extract and validate sheetData
+    // Поддержка пустого <sheetData/> или обычного открывающего-закрывающего тега
+    const sheetDataMatch = xml.match(/<sheetData([^>]*)>/);
+    if (!sheetDataMatch) {
+        return createError("Missing sheetData element");
     }
-    const sheetDataContent = xml.substring(sheetDataStart + 10, sheetDataEnd);
-    const rows = sheetDataContent.split("</row>");
-    if (rows.length < 2) {
-        return createError("SheetData should contain at least one row");
+    const isSelfClosing = sheetDataMatch[1]?.includes("/"); // <sheetData/> самозакрывающийся
+    let sheetDataContent = "";
+    if (!isSelfClosing) {
+        const sheetDataStart = sheetDataMatch.index + sheetDataMatch[0].length;
+        const sheetDataEnd = xml.indexOf("</sheetData>", sheetDataStart);
+        if (sheetDataEnd === -1) {
+            return createError("Invalid sheetData structure: missing closing tag");
+        }
+        sheetDataContent = xml.substring(sheetDataStart, sheetDataEnd);
     }
+    // Разбиваем на строки, если есть содержимое
+    const rows = sheetDataContent
+        ? sheetDataContent.split("</row>").map(r => r.trim()).filter(r => r.length)
+        : [];
     // Collect information about all rows and cells
     const allRows = [];
     const allCells = [];

package/build/esm/lib/utils/index.js

@@ -1,3 +1,4 @@
+export * from "./escape-xml.js";
 export * from "./get-max-row-number.js";
 export * from "./is-same-buffer.js";
 export * from "./remove-sheet-by-name.js";
@@ -5,3 +6,4 @@ export * from "./remove-sheet-from-content-types.js";
 export * from "./remove-sheet-from-rels.js";
 export * from "./remove-sheet-from-workbook.js";
 export * from "./shift-cell-ref.js";
+export * from "./trim-and-join-multiline.js";

package/build/esm/lib/utils/trim-and-join-multiline.js

@@ -0,0 +1,29 @@
+/**
+ * Trims whitespace from multiline strings and joins them with a specified separator.
+ *
+ * This function processes multiline text by:
+ * - Splitting the input string by line breaks (handles both \n and \r\n)
+ * - Trimming whitespace from each line
+ * - Optionally normalizing multiple spaces to single spaces
+ * - Optionally filtering out empty lines
+ * - Joining the processed lines with a custom separator
+ *
+ * @param options - Configuration object for processing the multiline string
+ * @param options.inputString - The multiline string to process
+ * @param options.keepEmptyLines - Whether to preserve empty lines in the output (default: false)
+ * @param options.normalizeSpaces - Whether to normalize multiple consecutive spaces to single spaces (default: true)
+ * @param options.separator - The string to use when joining lines (default: " ")
+ * @returns The processed string with lines joined by the separator
+ */
+export function trimAndJoinMultiline(options) {
+    const { inputString, keepEmptyLines = false, normalizeSpaces = true, separator = " ", } = options;
+    const lines = inputString.split(/\r?\n/);
+    let trimmedLines = lines.map(line => line.trim());
+    if (normalizeSpaces) {
+        trimmedLines = trimmedLines.map(line => line.replace(/\s+/g, " "));
+    }
+    const filteredLines = keepEmptyLines
+        ? trimmedLines
+        : trimmedLines.filter(line => line.length > 0);
+    return filteredLines.join(separator);
+}

package/build/esm/lib/workbook-builder/default/border.js

@@ -0,0 +1,14 @@
+/**
+ * Creates a basic empty border XML node.
+ *
+ * @returns XML node representing an empty border with left, right, top, and bottom elements
+ */
+export const border = () => ({
+    children: [
+        { tag: "left" },
+        { tag: "right" },
+        { tag: "top" },
+        { tag: "bottom" },
+    ],
+    tag: "border",
+});

package/build/esm/lib/workbook-builder/default/cell-xf.js

@@ -0,0 +1,11 @@
+/**
+ * Creates a default cell formatting object.
+ *
+ * @returns Cell formatting object with default IDs
+ */
+export const cellXf = () => ({
+    borderId: 0,
+    fillId: 0,
+    fontId: 0,
+    numFmtId: 0,
+});

package/build/esm/lib/workbook-builder/default/fill.js

@@ -0,0 +1,14 @@
+/**
+ * Creates a basic fill XML node with no pattern.
+ *
+ * @returns XML node representing an empty pattern fill
+ */
+export const fill = () => ({
+    children: [
+        {
+            attrs: { patternType: "none" },
+            tag: "patternFill",
+        },
+    ],
+    tag: "fill",
+});

package/build/esm/lib/workbook-builder/default/font.js

@@ -0,0 +1,15 @@
+/**
+ * Creates a default font XML node with Calibri font.
+ *
+ * @returns XML node representing a default font configuration
+ */
+export const font = () => ({
+    children: [
+        { attrs: { val: "11" }, tag: "sz" },
+        { attrs: { theme: "1" }, tag: "color" },
+        { attrs: { val: "Calibri" }, tag: "name" },
+        { attrs: { val: "2" }, tag: "family" },
+        { attrs: { val: "minor" }, tag: "scheme" },
+    ],
+    tag: "font",
+});