@cj-tech-master/excelts 1.6.3 → 2.0.0

package/dist/esm/csv/csv-stream.js

@@ -0,0 +1,638 @@
+/**
+ * CSV Streaming Support for Node.js
+ *
+ * Provides true streaming CSV parsing and formatting using Node.js streams.
+ * This enables processing of large CSV files without loading them entirely into memory.
+ */
+import { Transform } from "stream";
+import { isSyncTransform, isSyncValidate } from "./csv-core.js";
+/**
+ * Transform stream that parses CSV data row by row
+ *
+ * @example
+ * ```ts
+ * const parser = new CsvParserStream({ headers: true });
+ * fs.createReadStream('data.csv')
+ *   .pipe(parser)
+ *   .on('data', (row) => console.log(row));
+ * ```
+ */
+export class CsvParserStream extends Transform {
+    constructor(options = {}) {
+        super({ objectMode: options.objectMode !== false });
+        this.buffer = "";
+        this.currentRow = [];
+        this.currentField = "";
+        this.inQuotes = false;
+        this.lineNumber = 0;
+        this.rowCount = 0;
+        this.skippedDataRows = 0;
+        this.headerRow = null;
+        this.headersEmitted = false;
+        this._rowTransform = null;
+        this._rowValidator = null;
+        this.options = options;
+        this.encoding = options.encoding ?? "utf8";
+        const quoteOption = options.quote ?? '"';
+        this.quoteEnabled = quoteOption !== null && quoteOption !== false;
+        this.quote = this.quoteEnabled ? String(quoteOption) : "";
+        const escapeOption = options.escape ?? '"';
+        this.escape =
+            escapeOption !== null && escapeOption !== false ? String(escapeOption) : this.quote;
+        this.delimiter = options.delimiter ?? ",";
+    }
+    /**
+     * Set a transform function to modify rows before emitting
+     * Supports both sync and async transforms
+     */
+    transform(transformFunction) {
+        if (typeof transformFunction !== "function") {
+            throw new TypeError("The transform should be a function");
+        }
+        if (isSyncTransform(transformFunction)) {
+            this._rowTransform = (row, cb) => {
+                try {
+                    const result = transformFunction(row);
+                    cb(null, result);
+                }
+                catch (e) {
+                    cb(e);
+                }
+            };
+        }
+        else {
+            this._rowTransform = transformFunction;
+        }
+        return this;
+    }
+    /**
+     * Set a validate function to filter rows
+     * Invalid rows emit 'data-invalid' event
+     */
+    validate(validateFunction) {
+        if (typeof validateFunction !== "function") {
+            throw new TypeError("The validate should be a function");
+        }
+        if (isSyncValidate(validateFunction)) {
+            this._rowValidator = (row, cb) => {
+                try {
+                    const isValid = validateFunction(row);
+                    cb(null, isValid);
+                }
+                catch (e) {
+                    cb(e);
+                }
+            };
+        }
+        else {
+            this._rowValidator = validateFunction;
+        }
+        return this;
+    }
+    _transform(chunk, encoding, callback) {
+        try {
+            const data = typeof chunk === "string" ? chunk : chunk.toString(this.encoding);
+            this.buffer += data;
+            this.processBuffer(callback);
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+    _flush(callback) {
+        try {
+            // Process any remaining data
+            if (this.currentField !== "" || this.currentRow.length > 0) {
+                const { trim = false, ltrim = false, rtrim = false } = this.options;
+                this.currentRow.push(this.applyTrim(this.currentField, trim, ltrim, rtrim));
+                this.emitRow(callback);
+            }
+            else {
+                callback();
+            }
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+    applyTrim(field, trim, ltrim, rtrim) {
+        if (trim) {
+            return field.trim();
+        }
+        let result = field;
+        if (ltrim) {
+            result = result.trimStart();
+        }
+        if (rtrim) {
+            result = result.trimEnd();
+        }
+        return result;
+    }
+    processBuffer(callback) {
+        const { skipEmptyLines = false, ignoreEmpty = false, trim = false, ltrim = false, rtrim = false, headers = false, renameHeaders = false, comment, maxRows, skipLines = 0, skipRows = 0, strictColumnHandling = false, discardUnmappedColumns = false } = this.options;
+        const shouldSkipEmpty = skipEmptyLines || ignoreEmpty;
+        let i = 0;
+        const pendingRows = [];
+        while (i < this.buffer.length) {
+            const char = this.buffer[i];
+            const nextChar = this.buffer[i + 1];
+            if (this.inQuotes && this.quoteEnabled) {
+                if (this.escape && char === this.escape && nextChar === this.quote) {
+                    this.currentField += this.quote;
+                    i += 2;
+                }
+                else if (char === this.quote) {
+                    this.inQuotes = false;
+                    i++;
+                }
+                else if (i === this.buffer.length - 1) {
+                    // Need more data - preserve buffer from current position
+                    this.buffer = this.buffer.slice(i);
+                    this.processPendingRows(pendingRows, callback);
+                    return;
+                }
+                else {
+                    this.currentField += char;
+                    i++;
+                }
+            }
+            else {
+                if (this.quoteEnabled && char === this.quote && this.currentField === "") {
+                    this.inQuotes = true;
+                    i++;
+                }
+                else if (char === this.delimiter) {
+                    this.currentRow.push(this.applyTrim(this.currentField, trim, ltrim, rtrim));
+                    this.currentField = "";
+                    i++;
+                }
+                else if (char === "\n" || char === "\r") {
+                    // Handle \r\n
+                    if (char === "\r" && nextChar === "\n") {
+                        i++;
+                    }
+                    this.currentRow.push(this.applyTrim(this.currentField, trim, ltrim, rtrim));
+                    this.currentField = "";
+                    this.lineNumber++;
+                    // Skip lines at beginning
+                    if (this.lineNumber <= skipLines) {
+                        this.currentRow = [];
+                        i++;
+                        continue;
+                    }
+                    // Skip comment lines
+                    if (comment && this.currentRow[0]?.startsWith(comment)) {
+                        this.currentRow = [];
+                        i++;
+                        continue;
+                    }
+                    // Skip empty lines
+                    const isEmpty = this.currentRow.length === 1 && this.currentRow[0] === "";
+                    if (shouldSkipEmpty && isEmpty) {
+                        this.currentRow = [];
+                        i++;
+                        continue;
+                    }
+                    // Handle headers
+                    if ((headers === true ||
+                        typeof headers === "function" ||
+                        (Array.isArray(headers) && renameHeaders)) &&
+                        this.headerRow === null) {
+                        if (typeof headers === "function") {
+                            const transformed = headers(this.currentRow);
+                            this.headerRow = transformed.filter((h) => h != null);
+                        }
+                        else if (Array.isArray(headers) && renameHeaders) {
+                            // Discard first row, use provided headers
+                            this.headerRow = headers.filter((h) => h != null);
+                        }
+                        else {
+                            this.headerRow = this.currentRow;
+                        }
+                        // Emit headers event
+                        if (!this.headersEmitted) {
+                            this.headersEmitted = true;
+                            this.emit("headers", this.headerRow);
+                        }
+                        this.currentRow = [];
+                        i++;
+                        continue;
+                    }
+                    // Use provided headers array directly if no renameHeaders
+                    if (Array.isArray(headers) && !renameHeaders && this.headerRow === null) {
+                        this.headerRow = headers.filter((h) => h != null);
+                        // Emit headers event for provided headers
+                        if (!this.headersEmitted) {
+                            this.headersEmitted = true;
+                            this.emit("headers", this.headerRow);
+                        }
+                    }
+                    // Skip data rows
+                    if (this.skippedDataRows < skipRows) {
+                        this.skippedDataRows++;
+                        this.currentRow = [];
+                        i++;
+                        continue;
+                    }
+                    // Column validation
+                    if (this.headerRow && this.headerRow.length > 0) {
+                        const expectedCols = this.headerRow.length;
+                        const actualCols = this.currentRow.length;
+                        if (actualCols > expectedCols) {
+                            if (strictColumnHandling && !discardUnmappedColumns) {
+                                // Emit data-invalid event
+                                this.emit("data-invalid", this.currentRow, `Column mismatch: expected ${expectedCols}, got ${actualCols}`);
+                                this.currentRow = [];
+                                i++;
+                                continue;
+                            }
+                            else {
+                                // Discard extra columns
+                                this.currentRow.length = expectedCols;
+                            }
+                        }
+                        else if (actualCols < expectedCols) {
+                            if (strictColumnHandling) {
+                                this.emit("data-invalid", this.currentRow, `Column mismatch: expected ${expectedCols}, got ${actualCols}`);
+                                this.currentRow = [];
+                                i++;
+                                continue;
+                            }
+                            // Pad with empty strings
+                            while (this.currentRow.length < expectedCols) {
+                                this.currentRow.push("");
+                            }
+                        }
+                    }
+                    this.rowCount++;
+                    // Check max rows
+                    if (maxRows !== undefined && this.rowCount > maxRows) {
+                        this.buffer = "";
+                        this.processPendingRows(pendingRows, callback);
+                        return;
+                    }
+                    // Queue this row for emission
+                    const rowToEmit = this.currentRow;
+                    this.currentRow = [];
+                    pendingRows.push({
+                        row: this.buildRow(rowToEmit),
+                        callback: () => { }
+                    });
+                    i++;
+                }
+                else {
+                    this.currentField += char;
+                    i++;
+                }
+            }
+        }
+        this.buffer = "";
+        this.processPendingRows(pendingRows, callback);
+    }
+    buildRow(rawRow) {
+        if (this.options.headers && this.headerRow) {
+            const obj = {};
+            this.headerRow.forEach((header, index) => {
+                obj[header] = rawRow[index] ?? "";
+            });
+            return obj;
+        }
+        return rawRow;
+    }
+    processPendingRows(rows, callback) {
+        if (rows.length === 0) {
+            callback();
+            return;
+        }
+        let index = 0;
+        const processNext = () => {
+            if (index >= rows.length) {
+                callback();
+                return;
+            }
+            const { row } = rows[index];
+            index++;
+            this.transformAndValidateRow(row, (err, result) => {
+                if (err) {
+                    callback(err);
+                    return;
+                }
+                if (result && result.isValid && result.row !== null) {
+                    // Push the row (respect objectMode)
+                    if (this.options.objectMode === false) {
+                        this.push(JSON.stringify(result.row));
+                    }
+                    else {
+                        this.push(result.row);
+                    }
+                }
+                else if (result && !result.isValid) {
+                    this.emit("data-invalid", result.row, result.reason);
+                }
+                // Use setImmediate to prevent stack overflow for large datasets
+                if (index % 1000 === 0) {
+                    setImmediate(processNext);
+                }
+                else {
+                    processNext();
+                }
+            });
+        };
+        processNext();
+    }
+    transformAndValidateRow(row, callback) {
+        // First apply transform
+        if (this._rowTransform) {
+            this._rowTransform(row, (transformErr, transformedRow) => {
+                if (transformErr) {
+                    callback(transformErr);
+                    return;
+                }
+                if (transformedRow === null || transformedRow === undefined) {
+                    callback(null, { row: null, isValid: true });
+                    return;
+                }
+                // Then validate
+                this.validateRow(transformedRow, callback);
+            });
+        }
+        else {
+            this.validateRow(row, callback);
+        }
+    }
+    validateRow(row, callback) {
+        if (this._rowValidator) {
+            this._rowValidator(row, (validateErr, isValid, reason) => {
+                if (validateErr) {
+                    callback(validateErr);
+                    return;
+                }
+                callback(null, { row, isValid: isValid ?? false, reason });
+            });
+        }
+        else {
+            callback(null, { row, isValid: true });
+        }
+    }
+    emitRow(callback) {
+        const row = this.buildRow(this.currentRow);
+        this.transformAndValidateRow(row, (err, result) => {
+            if (err) {
+                if (callback) {
+                    callback(err);
+                }
+                return;
+            }
+            if (result && result.isValid && result.row !== null) {
+                if (this.options.objectMode === false) {
+                    this.push(JSON.stringify(result.row));
+                }
+                else {
+                    this.push(result.row);
+                }
+            }
+            else if (result && !result.isValid) {
+                this.emit("data-invalid", result.row, result.reason);
+            }
+            if (callback) {
+                callback();
+            }
+        });
+    }
+}
+/**
+ * Transform stream that formats rows to CSV
+ *
+ * @example
+ * ```ts
+ * const formatter = new CsvFormatterStream({ headers: ['name', 'age'] });
+ * formatter.pipe(fs.createWriteStream('output.csv'));
+ * formatter.write(['Alice', 30]);
+ * formatter.write(['Bob', 25]);
+ * formatter.end();
+ * ```
+ */
+export class CsvFormatterStream extends Transform {
+    constructor(options = {}) {
+        super({
+            objectMode: options.objectMode !== false,
+            writableObjectMode: options.objectMode !== false
+        });
+        this.headerWritten = false;
+        this.headers = null;
+        this.rowCount = 0;
+        this._rowTransform = null;
+        this.options = options;
+        const quoteOption = options.quote ?? '"';
+        this.quoteEnabled = quoteOption !== null && quoteOption !== false;
+        this.quote = this.quoteEnabled ? String(quoteOption) : "";
+        const escapeOption = options.escape;
+        this.escape =
+            escapeOption !== undefined && escapeOption !== null && escapeOption !== false
+                ? String(escapeOption)
+                : this.quote;
+        this.delimiter = options.delimiter ?? ",";
+        this.rowDelimiter = options.rowDelimiter ?? "\n";
+        this.alwaysQuote = options.alwaysQuote ?? false;
+        // writeHeaders defaults to true when headers is provided
+        this.shouldWriteHeaders = options.writeHeaders ?? true;
+        if (Array.isArray(options.headers)) {
+            this.headers = options.headers;
+        }
+        // Set up transform from options
+        if (options.transform) {
+            this.transform(options.transform);
+        }
+    }
+    /**
+     * Set a transform function to modify rows before formatting
+     */
+    transform(transformFunction) {
+        if (typeof transformFunction !== "function") {
+            throw new TypeError("The transform should be a function");
+        }
+        if (isSyncTransform(transformFunction)) {
+            this._rowTransform = (row, cb) => {
+                try {
+                    const result = transformFunction(row);
+                    cb(null, result);
+                }
+                catch (e) {
+                    cb(e);
+                }
+            };
+        }
+        else {
+            this._rowTransform = transformFunction;
+        }
+        return this;
+    }
+    _transform(chunk, encoding, callback) {
+        try {
+            // Write BOM if first chunk
+            if (!this.headerWritten && this.options.writeBOM) {
+                this.push("\uFEFF");
+            }
+            // Write headers if needed
+            if (!this.headerWritten && this.headers && this.shouldWriteHeaders) {
+                this.push(this.formatRow(this.headers, true));
+                this.headerWritten = true;
+            }
+            else if (!this.headerWritten &&
+                this.options.headers === true &&
+                !Array.isArray(chunk) &&
+                this.shouldWriteHeaders) {
+                // Auto-detect headers from first object
+                this.headers = Object.keys(chunk);
+                this.push(this.formatRow(this.headers, true));
+                this.headerWritten = true;
+            }
+            else if (!this.headerWritten) {
+                // Mark header as "written" even if we skip it (to handle subsequent rows)
+                if (this.options.headers === true && !Array.isArray(chunk)) {
+                    this.headers = Object.keys(chunk);
+                }
+                this.headerWritten = true;
+            }
+            // Apply transform if set
+            if (this._rowTransform) {
+                this._rowTransform(chunk, (err, transformedRow) => {
+                    if (err) {
+                        callback(err);
+                        return;
+                    }
+                    if (transformedRow === null || transformedRow === undefined) {
+                        callback();
+                        return;
+                    }
+                    this.formatAndPush(transformedRow);
+                    callback();
+                });
+            }
+            else {
+                this.formatAndPush(chunk);
+                callback();
+            }
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+    _flush(callback) {
+        // Handle alwaysWriteHeaders with no data
+        if (!this.headerWritten &&
+            this.options.alwaysWriteHeaders &&
+            this.headers &&
+            this.shouldWriteHeaders) {
+            if (this.options.writeBOM) {
+                this.push("\uFEFF");
+            }
+            this.push(this.formatRow(this.headers, true));
+            this.headerWritten = true;
+        }
+        // Add trailing row delimiter if includeEndRowDelimiter is true
+        if (this.options.includeEndRowDelimiter && this.rowCount > 0) {
+            this.push(this.rowDelimiter);
+        }
+        callback();
+    }
+    formatAndPush(chunk) {
+        let row;
+        if (Array.isArray(chunk)) {
+            row = chunk;
+        }
+        else if (typeof chunk === "object" && chunk !== null) {
+            row = this.headers ? this.headers.map(h => chunk[h]) : Object.values(chunk);
+        }
+        else {
+            row = [chunk];
+        }
+        this.push(this.formatRow(row, false));
+    }
+    formatRow(row, isHeader = false) {
+        const { quoteColumns, quoteHeaders } = this.options;
+        const quoteConfig = isHeader ? quoteHeaders : quoteColumns;
+        const fields = row.map((field, index) => {
+            const headerName = this.headers?.[index];
+            const shouldForceQuote = this.shouldQuoteField(index, headerName, quoteConfig);
+            return this.formatField(field, shouldForceQuote);
+        });
+        const formattedRow = fields.join(this.delimiter);
+        // Use row delimiter as prefix (except for first row)
+        // rowDelimiter separates rows, no trailing delimiter by default
+        if (this.rowCount === 0) {
+            this.rowCount++;
+            return formattedRow;
+        }
+        this.rowCount++;
+        return this.rowDelimiter + formattedRow;
+    }
+    shouldQuoteField(index, header, quoteConfig) {
+        if (quoteConfig === true) {
+            return true;
+        }
+        if (quoteConfig === false || quoteConfig === undefined) {
+            return false;
+        }
+        if (Array.isArray(quoteConfig)) {
+            return quoteConfig[index] === true;
+        }
+        if (typeof quoteConfig === "object" && header) {
+            return quoteConfig[header] === true;
+        }
+        return false;
+    }
+    formatField(value, forceQuote = false) {
+        if (value === null || value === undefined) {
+            return "";
+        }
+        const str = String(value);
+        if (!this.quoteEnabled) {
+            return str;
+        }
+        // Check if quoting is needed
+        const needsQuote = this.alwaysQuote ||
+            forceQuote ||
+            str.includes(this.delimiter) ||
+            str.includes(this.quote) ||
+            str.includes("\r") ||
+            str.includes("\n");
+        if (needsQuote) {
+            const escaped = str.replace(new RegExp(escapeRegex(this.quote), "g"), this.escape + this.quote);
+            return this.quote + escaped + this.quote;
+        }
+        return str;
+    }
+}
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Create a readable stream from an array of rows
+ */
+export function createCsvReadableStream(rows, options = {}) {
+    const formatter = new CsvFormatterStream(options);
+    // Use setImmediate to allow piping before data flows
+    setImmediate(() => {
+        for (const row of rows) {
+            formatter.write(row);
+        }
+        formatter.end();
+    });
+    return formatter;
+}
+/**
+ * Create parser stream factory
+ */
+export function createCsvParserStream(options = {}) {
+    return new CsvParserStream(options);
+}
+/**
+ * Create formatter stream factory
+ */
+export function createCsvFormatterStream(options = {}) {
+    return new CsvFormatterStream(options);
+}