@cj-tech-master/excelts 1.6.2 → 1.6.3-canary.20251224124621.73c5d94

package/dist/esm/csv/csv.base.js

@@ -0,0 +1,141 @@
+/**
+ * CSV Base class - Shared functionality for Node.js and Browser
+ *
+ * Uses native CSV parser (RFC 4180 compliant) with zero external dependencies.
+ * Date parsing uses dayjs for format flexibility.
+ */
+import dayjs from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat.js";
+import utc from "dayjs/plugin/utc.js";
+import { parseCsv, formatCsv } from "./csv-core.js";
+// Initialize dayjs plugins
+dayjs.extend(customParseFormat);
+dayjs.extend(utc);
+// Special Excel values mapping
+const SpecialValues = {
+    true: true,
+    false: false,
+    "#N/A": { error: "#N/A" },
+    "#REF!": { error: "#REF!" },
+    "#NAME?": { error: "#NAME?" },
+    "#DIV/0!": { error: "#DIV/0!" },
+    "#NULL!": { error: "#NULL!" },
+    "#VALUE!": { error: "#VALUE!" },
+    "#NUM!": { error: "#NUM!" }
+};
+/**
+ * Create the default value mapper for CSV parsing
+ */
+export function createDefaultValueMapper(dateFormats) {
+    return function mapValue(datum) {
+        if (datum === "") {
+            return null;
+        }
+        // Try to parse as number
+        const datumNumber = Number(datum);
+        if (!Number.isNaN(datumNumber) && datumNumber !== Infinity) {
+            return datumNumber;
+        }
+        // Try to parse as date
+        const dt = dateFormats.reduce((matchingDate, currentDateFormat) => {
+            if (matchingDate) {
+                return matchingDate;
+            }
+            const dayjsObj = dayjs(datum, currentDateFormat, true);
+            if (dayjsObj.isValid()) {
+                return dayjsObj;
+            }
+            return null;
+        }, null);
+        if (dt) {
+            return new Date(dt.valueOf());
+        }
+        // Check for special values
+        const special = SpecialValues[datum];
+        if (special !== undefined) {
+            return special;
+        }
+        return datum;
+    };
+}
+/**
+ * Create the default value mapper for CSV writing
+ */
+export function createDefaultWriteMapper(dateFormat, dateUTC) {
+    return function mapValue(value) {
+        if (value) {
+            // Handle hyperlinks
+            if (value.text || value.hyperlink) {
+                return value.hyperlink || value.text || "";
+            }
+            // Handle formulas
+            if (value.formula || value.result) {
+                return value.result || "";
+            }
+            // Handle dates
+            if (value instanceof Date) {
+                if (dateFormat) {
+                    return dateUTC ? dayjs.utc(value).format(dateFormat) : dayjs(value).format(dateFormat);
+                }
+                return dateUTC ? dayjs.utc(value).format() : dayjs(value).format();
+            }
+            // Handle errors
+            if (value.error) {
+                return value.error;
+            }
+            // Handle other objects
+            if (typeof value === "object") {
+                return JSON.stringify(value);
+            }
+        }
+        return value;
+    };
+}
+/**
+ * Parse CSV content into a worksheet
+ */
+export function parseCsvToWorksheet(content, workbook, options = {}) {
+    const worksheet = workbook.addWorksheet(options.sheetName);
+    const dateFormats = options.dateFormats || [
+        "YYYY-MM-DD[T]HH:mm:ssZ",
+        "YYYY-MM-DD[T]HH:mm:ss",
+        "MM-DD-YYYY",
+        "YYYY-MM-DD"
+    ];
+    const map = options.map || createDefaultValueMapper(dateFormats);
+    // Parse CSV
+    const rows = parseCsv(content, options.parserOptions);
+    // Add rows to worksheet
+    for (const row of rows) {
+        worksheet.addRow(row.map(map));
+    }
+    return worksheet;
+}
+/**
+ * Format worksheet as CSV string
+ */
+export function formatWorksheetToCsv(worksheet, options = {}) {
+    if (!worksheet) {
+        return "";
+    }
+    const { dateFormat, dateUTC } = options;
+    const map = options.map || createDefaultWriteMapper(dateFormat, dateUTC);
+    const includeEmptyRows = options.includeEmptyRows !== false;
+    const rows = [];
+    let lastRow = 1;
+    worksheet.eachRow((row, rowNumber) => {
+        // Add empty rows if needed
+        if (includeEmptyRows) {
+            while (lastRow++ < rowNumber - 1) {
+                rows.push([]);
+            }
+        }
+        const { values } = row;
+        values.shift(); // Remove first empty element (1-indexed)
+        rows.push(values.map(map));
+        lastRow = rowNumber;
+    });
+    return formatCsv(rows, options.formatterOptions);
+}
+// Re-export core types
+export { parseCsv, formatCsv, parseCsvStream } from "./csv-core.js";

package/dist/esm/csv/csv.browser.js

@@ -0,0 +1,65 @@
+/**
+ * CSV class for Browser - No file system dependencies
+ *
+ * Provides:
+ * - load: Load from string or ArrayBuffer
+ * - writeString: Write to string
+ * - writeBuffer: Write to Uint8Array
+ */
+import { parseCsvToWorksheet, formatWorksheetToCsv } from "./csv.base.js";
+class CSV {
+    constructor(workbook) {
+        this.workbook = workbook;
+    }
+    /**
+     * Load CSV from string or ArrayBuffer
+     */
+    load(data, options) {
+        let content;
+        if (typeof data === "string") {
+            content = data;
+        }
+        else if (data instanceof ArrayBuffer) {
+            content = new TextDecoder("utf-8").decode(data);
+        }
+        else if (data instanceof Uint8Array) {
+            content = new TextDecoder("utf-8").decode(data);
+        }
+        else {
+            throw new Error("Invalid data type. Expected string, ArrayBuffer, or Uint8Array.");
+        }
+        return parseCsvToWorksheet(content, this.workbook, options);
+    }
+    /**
+     * Write CSV to string
+     */
+    writeString(options) {
+        const worksheet = this.workbook.getWorksheet(options?.sheetName || options?.sheetId);
+        return formatWorksheetToCsv(worksheet, options);
+    }
+    /**
+     * Write CSV to Uint8Array buffer
+     */
+    writeBuffer(options) {
+        const content = this.writeString(options);
+        return new TextEncoder().encode(content);
+    }
+    // Stubs for unsupported methods - throw helpful errors
+    async readFile(_filename, _options) {
+        throw new Error("CSV.readFile() is not available in browser. " +
+            "Use CSV.load() with string or ArrayBuffer instead.");
+    }
+    async read(_stream, _options) {
+        throw new Error("CSV.read() stream is not available in browser. " +
+            "Use CSV.load() with string or ArrayBuffer instead.");
+    }
+    async writeFile(_filename, _options) {
+        throw new Error("CSV.writeFile() is not available in browser. " +
+            "Use CSV.writeString() or CSV.writeBuffer() and handle download manually.");
+    }
+    write(_stream, _options) {
+        throw new Error("CSV.write() stream is not available in browser. " +
+            "Use CSV.writeString() or CSV.writeBuffer() instead.");
+    }
+}
+export { CSV };

package/dist/esm/csv/csv.js

@@ -1,187 +1,217 @@
+/**
+ * CSV class for Node.js - Full streaming and file system support
+ *
+ * Features:
+ * - readFile: Read from file path (streaming)
+ * - writeFile: Write to file path (streaming)
+ * - read: Read from Node.js stream
+ * - write: Write to Node.js stream
+ * - createReadStream: Create a readable stream from worksheet
+ * - createWriteStream: Create a writable stream that writes to worksheet
+ */
 import fs from "fs";
-import { StreamBuf } from "../utils/stream-buf.js";
-import { format, parse } from "fast-csv";
-import customParseFormat from "dayjs/plugin/customParseFormat.js";
-import utc from "dayjs/plugin/utc.js";
-import dayjs from "dayjs";
+import {} from "stream";
 import { fileExists } from "../utils/utils.js";
-const SpecialValues = {
-    true: true,
-    false: false,
-    "#N/A": { error: "#N/A" },
-    "#REF!": { error: "#REF!" },
-    "#NAME?": { error: "#NAME?" },
-    "#DIV/0!": { error: "#DIV/0!" },
-    "#NULL!": { error: "#NULL!" },
-    "#VALUE!": { error: "#VALUE!" },
-    "#NUM!": { error: "#NUM!" }
-};
-dayjs.extend(customParseFormat);
-dayjs.extend(utc);
+import { createDefaultValueMapper, createDefaultWriteMapper } from "./csv.base.js";
+import { CsvParserStream, CsvFormatterStream } from "./csv-stream.js";
 class CSV {
     constructor(workbook) {
         this.workbook = workbook;
-        this.worksheet = null;
     }
+    /**
+     * Read CSV from file using streaming
+     *
+     * @example
+     * ```ts
+     * const worksheet = await workbook.csv.readFile('data.csv');
+     * ```
+     */
     async readFile(filename, options) {
-        options = options || {};
         if (!(await fileExists(filename))) {
             throw new Error(`File not found: ${filename}`);
         }
-        const stream = fs.createReadStream(filename);
-        try {
-            const worksheet = await this.read(stream, options);
-            stream.close();
-            return worksheet;
-        }
-        catch (error) {
-            stream.close();
-            throw error;
-        }
+        const readStream = fs.createReadStream(filename, {
+            encoding: "utf8",
+            highWaterMark: options?.highWaterMark ?? 64 * 1024
+        });
+        return this.read(readStream, options);
     }
-    read(stream, options) {
-        options = options || {};
+    /**
+     * Read CSV from Node.js readable stream
+     *
+     * Uses true streaming - processes data row by row without loading entire file into memory.
+     *
+     * @example
+     * ```ts
+     * const stream = fs.createReadStream('data.csv');
+     * const worksheet = await workbook.csv.read(stream);
+     * ```
+     */
+    async read(stream, options) {
+        const worksheet = this.workbook.addWorksheet(options?.sheetName);
+        const dateFormats = options?.dateFormats || [
+            "YYYY-MM-DD[T]HH:mm:ssZ",
+            "YYYY-MM-DD[T]HH:mm:ss",
+            "MM-DD-YYYY",
+            "YYYY-MM-DD"
+        ];
+        const map = options?.map || createDefaultValueMapper(dateFormats);
+        const parser = new CsvParserStream(options?.parserOptions);
         return new Promise((resolve, reject) => {
-            const worksheet = this.workbook.addWorksheet(options.sheetName);
-            const dateFormats = options.dateFormats || [
-                "YYYY-MM-DD[T]HH:mm:ssZ",
-                "YYYY-MM-DD[T]HH:mm:ss",
-                "MM-DD-YYYY",
-                "YYYY-MM-DD"
-            ];
-            const map = options.map ||
-                function (datum) {
-                    if (datum === "") {
-                        return null;
-                    }
-                    const datumNumber = Number(datum);
-                    if (!Number.isNaN(datumNumber) && datumNumber !== Infinity) {
-                        return datumNumber;
-                    }
-                    const dt = dateFormats.reduce((matchingDate, currentDateFormat) => {
-                        if (matchingDate) {
-                            return matchingDate;
-                        }
-                        const dayjsObj = dayjs(datum, currentDateFormat, true);
-                        if (dayjsObj.isValid()) {
-                            return dayjsObj;
-                        }
-                        return null;
-                    }, null);
-                    if (dt) {
-                        return new Date(dt.valueOf());
-                    }
-                    const special = SpecialValues[datum];
-                    if (special !== undefined) {
-                        return special;
-                    }
-                    return datum;
-                };
-            const onData = (data) => {
-                worksheet.addRow(data.map(map));
-            };
-            const onEnd = () => {
-                csvStream.emit("worksheet", worksheet);
-            };
-            const cleanup = () => {
-                csvStream.removeListener("data", onData);
-                csvStream.removeListener("end", onEnd);
-                csvStream.removeListener("worksheet", onWorksheet);
-                csvStream.removeListener("error", onError);
-            };
-            const onWorksheet = (ws) => {
-                cleanup();
-                resolve(ws);
-            };
-            const onError = (err) => {
-                cleanup();
-                reject(err);
-            };
-            const csvStream = parse(options.parserOptions).on("data", onData).on("end", onEnd);
-            csvStream.once("worksheet", onWorksheet).on("error", onError);
-            stream.pipe(csvStream);
+            stream.pipe(parser);
+            parser.on("data", (row) => {
+                worksheet.addRow(row.map(map));
+            });
+            parser.on("end", () => {
+                resolve(worksheet);
+            });
+            parser.on("error", reject);
+            stream.on("error", reject);
         });
     }
-    write(stream, options) {
+    /**
+     * Write CSV to file using streaming
+     *
+     * @example
+     * ```ts
+     * await workbook.csv.writeFile('output.csv');
+     * ```
+     */
+    async writeFile(filename, options) {
+        const writeStream = fs.createWriteStream(filename, {
+            encoding: (options?.encoding || "utf8"),
+            highWaterMark: options?.highWaterMark ?? 64 * 1024
+        });
+        return this.write(writeStream, options);
+    }
+    /**
+     * Write CSV to Node.js writable stream
+     *
+     * Uses true streaming - writes data row by row.
+     *
+     * @example
+     * ```ts
+     * const stream = fs.createWriteStream('output.csv');
+     * await workbook.csv.write(stream);
+     * ```
+     */
+    async write(stream, options) {
+        const worksheet = this.workbook.getWorksheet(options?.sheetName || options?.sheetId);
+        if (!worksheet) {
+            stream.end();
+            return;
+        }
+        const { dateFormat, dateUTC } = options || {};
+        const map = options?.map || createDefaultWriteMapper(dateFormat, dateUTC);
+        const includeEmptyRows = options?.includeEmptyRows !== false;
+        const formatterOptions = {
+            ...options?.formatterOptions
+        };
+        const formatter = new CsvFormatterStream(formatterOptions);
+        formatter.pipe(stream);
+        let lastRow = 1;
+        worksheet.eachRow((row, rowNumber) => {
+            // Add empty rows if needed
+            if (includeEmptyRows) {
+                while (lastRow++ < rowNumber - 1) {
+                    formatter.write([]);
+                }
+            }
+            const { values } = row;
+            values.shift(); // Remove first empty element (1-indexed)
+            formatter.write(values.map(map));
+            lastRow = rowNumber;
+        });
         return new Promise((resolve, reject) => {
-            options = options || {};
-            // const encoding = options.encoding || 'utf8';
-            // const separator = options.separator || ',';
-            // const quoteChar = options.quoteChar || '\'';
-            const worksheet = this.workbook.getWorksheet(options.sheetName || options.sheetId);
-            const csvStream = format(options.formatterOptions);
-            const cleanup = () => {
-                stream.removeListener("finish", onFinish);
-                csvStream.removeListener("error", onError);
-            };
-            const onFinish = () => {
-                cleanup();
-                resolve();
-            };
-            const onError = (err) => {
-                cleanup();
-                reject(err);
-            };
-            stream.once("finish", onFinish);
-            csvStream.on("error", onError);
-            csvStream.pipe(stream);
-            const { dateFormat, dateUTC } = options;
-            const map = options.map ||
-                (value => {
-                    if (value) {
-                        if (value.text || value.hyperlink) {
-                            return value.hyperlink || value.text || "";
-                        }
-                        if (value.formula || value.result) {
-                            return value.result || "";
-                        }
-                        if (value instanceof Date) {
-                            if (dateFormat) {
-                                return dateUTC
-                                    ? dayjs.utc(value).format(dateFormat)
-                                    : dayjs(value).format(dateFormat);
-                            }
-                            return dateUTC ? dayjs.utc(value).format() : dayjs(value).format();
-                        }
-                        if (value.error) {
-                            return value.error;
-                        }
-                        if (typeof value === "object") {
-                            return JSON.stringify(value);
-                        }
-                    }
-                    return value;
-                });
-            const includeEmptyRows = options.includeEmptyRows === undefined || options.includeEmptyRows;
-            let lastRow = 1;
-            if (worksheet) {
+            formatter.on("error", reject);
+            stream.on("error", reject);
+            stream.on("finish", () => resolve());
+            formatter.end();
+        });
+    }
+    /**
+     * Write CSV to buffer
+     *
+     * Note: This loads the entire CSV into memory. For large files, use write() with a stream.
+     */
+    async writeBuffer(options) {
+        const chunks = [];
+        const { Writable } = await import("stream");
+        const bufferStream = new Writable({
+            write(chunk, encoding, callback) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding));
+                callback();
+            }
+        });
+        await this.write(bufferStream, options);
+        return Buffer.concat(chunks);
+    }
+    /**
+     * Create a readable stream that outputs CSV rows from the worksheet
+     *
+     * @example
+     * ```ts
+     * const csvStream = workbook.csv.createReadStream();
+     * csvStream.pipe(fs.createWriteStream('output.csv'));
+     * ```
+     */
+    createReadStream(options) {
+        const worksheet = this.workbook.getWorksheet(options?.sheetName || options?.sheetId);
+        const { dateFormat, dateUTC } = options || {};
+        const map = options?.map || createDefaultWriteMapper(dateFormat, dateUTC);
+        const includeEmptyRows = options?.includeEmptyRows !== false;
+        const formatterOptions = {
+            ...options?.formatterOptions
+        };
+        const formatter = new CsvFormatterStream(formatterOptions);
+        if (worksheet) {
+            // Use setImmediate to allow piping before data flows
+            setImmediate(() => {
+                let lastRow = 1;
                 worksheet.eachRow((row, rowNumber) => {
                     if (includeEmptyRows) {
                         while (lastRow++ < rowNumber - 1) {
-                            csvStream.write([]);
+                            formatter.write([]);
                         }
                     }
                     const { values } = row;
                     values.shift();
-                    csvStream.write(values.map(map));
+                    formatter.write(values.map(map));
                     lastRow = rowNumber;
                 });
-            }
-            csvStream.end();
-        });
-    }
-    writeFile(filename, options) {
-        options = options || {};
-        const streamOptions = {
-            encoding: (options.encoding || "utf8")
-        };
-        const stream = fs.createWriteStream(filename, streamOptions);
-        return this.write(stream, options);
+                formatter.end();
+            });
+        }
+        else {
+            setImmediate(() => formatter.end());
+        }
+        return formatter;
     }
-    async writeBuffer(options) {
-        const stream = new StreamBuf();
-        await this.write(stream, options);
-        return stream.read();
+    /**
+     * Create a writable stream that parses CSV and adds rows to a worksheet
+     *
+     * @example
+     * ```ts
+     * const csvWriter = workbook.csv.createWriteStream({ sheetName: 'Data' });
+     * fs.createReadStream('input.csv').pipe(csvWriter);
+     * await new Promise(resolve => csvWriter.on('finish', resolve));
+     * ```
+     */
+    createWriteStream(options) {
+        const worksheet = this.workbook.addWorksheet(options?.sheetName);
+        const dateFormats = options?.dateFormats || [
+            "YYYY-MM-DD[T]HH:mm:ssZ",
+            "YYYY-MM-DD[T]HH:mm:ss",
+            "MM-DD-YYYY",
+            "YYYY-MM-DD"
+        ];
+        const map = options?.map || createDefaultValueMapper(dateFormats);
+        const parser = new CsvParserStream(options?.parserOptions);
+        parser.on("data", (row) => {
+            worksheet.addRow(row.map(map));
+        });
+        return parser;
     }
 }
 export { CSV };
+export { CsvParserStream, CsvFormatterStream } from "./csv-stream.js";