csv-stream-lite 1.0.2 → 1.0.4

package/dist/parser.d.ts

@@ -9,6 +9,12 @@ export interface CsvEntityOptions {
     separator?: string;
     /** Character used to escape special characters. Defaults to '"' */
     escapeChar?: string;
+    /** Character used to quote fields. Defaults to escapeChar value */
+    quoteChar?: string;
+    /** String used to denote new lines. Defaults to auto-detected '\r', '\n', or '\r\n' */
+    newline?: string;
+    /** Whether to trim whitespace from fields. Defaults to false. NOTE: this option is not supported when streaming, as trimming requires buffering the entire field. */
+    trim?: boolean;
 }
 /**
  * Abstract base class for CSV entities that supports both synchronous and asynchronous parsing.
@@ -17,10 +23,13 @@ export interface CsvEntityOptions {
  * @typeParam T - The type returned by read operations
  * @typeParam S - The type yielded by stream operations (defaults to T)
  */
-export declare abstract class CsvEntity<T, S = T> implements Required<CsvEntityOptions> {
+export declare abstract class CsvEntity<T, S = T> {
     byteBuffer: ByteBuffer;
     separator: string;
     escapeChar: string;
+    quoteChar: string;
+    newline?: string;
+    trim: boolean;
     consumed: boolean;
     /**
      * Creates a new CSV entity.
@@ -96,6 +105,19 @@ export declare abstract class CsvEntity<T, S = T> implements Required<CsvEntityO
 export declare class CsvCell extends CsvEntity<string> {
     chunkSize: number;
     endOfLineReached: boolean;
+    /**
+     * Checks if the current buffer position starts with a line ending.
+     * Supports both default line endings (\r, \n, \r\n) and custom newline strings.
+     *
+     * @returns true if at the start of a line ending, false otherwise
+     */
+    private isAtLineEnd;
+    /**
+     * Consumes a line ending from the buffer.
+     * Handles both default line endings (\r, \n, \r\n) and custom newline strings.
+     * Should only be called after isAtLineEnd() returns true.
+     */
+    private consumeLineEnd;
     protected parse(): string;
     protected parseAsync(): Promise<string>;
     /**

package/dist/parser.js

@@ -31,6 +31,9 @@ export class CsvEntity {
     byteBuffer;
     separator = ',';
     escapeChar = '"';
+    quoteChar = '"';
+    newline;
+    trim = false;
     consumed = false;
     /**
      * Creates a new CSV entity.
@@ -49,6 +52,32 @@ export class CsvEntity {
         if (options?.escapeChar) {
             this.escapeChar = options.escapeChar;
         }
+        if (options?.quoteChar) {
+            this.quoteChar = options.quoteChar;
+        }
+        else if (options?.escapeChar) {
+            // Default quoteChar to escapeChar if only escapeChar is specified
+            this.quoteChar = options.escapeChar;
+        }
+        if (options?.trim !== undefined) {
+            this.trim = options.trim;
+        }
+        if (options?.newline !== undefined) {
+            const newline = options.newline;
+            if (newline === '') {
+                throw new Error('Invalid CSV newline: newline option must be a non-empty string.');
+            }
+            if (newline.includes(this.separator)) {
+                throw new Error('Invalid CSV newline: newline option must not contain the field separator character.');
+            }
+            if (newline.includes(this.escapeChar)) {
+                throw new Error('Invalid CSV newline: newline option must not contain the escape character.');
+            }
+            if (newline.includes(this.quoteChar)) {
+                throw new Error('Invalid CSV newline: newline option must not contain the quote character.');
+            }
+            this.newline = newline;
+        }
     }
     set maxBufferSize(size) {
         this.byteBuffer.maxBufferSize = size;
@@ -162,19 +191,68 @@ export class CsvEntity {
 export class CsvCell extends CsvEntity {
     chunkSize = DEFAULT_CHUNK_SIZE;
     endOfLineReached = false;
+    /**
+     * Checks if the current buffer position starts with a line ending.
+     * Supports both default line endings (\r, \n, \r\n) and custom newline strings.
+     *
+     * @returns true if at the start of a line ending, false otherwise
+     */
+    isAtLineEnd() {
+        if (this.newline !== undefined) {
+            // Check for custom newline string
+            for (let i = 0; i < this.newline.length; i++) {
+                const expectedByte = this.newline.charCodeAt(i);
+                const actualByte = this.byteBuffer.peek(i);
+                if (actualByte === null || actualByte !== expectedByte) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        else {
+            // Default behavior: check for \r or \n
+            return isLineEnd(this.byteBuffer.peek());
+        }
+    }
+    /**
+     * Consumes a line ending from the buffer.
+     * Handles both default line endings (\r, \n, \r\n) and custom newline strings.
+     * Should only be called after isAtLineEnd() returns true.
+     */
+    consumeLineEnd() {
+        if (this.newline !== undefined) {
+            // Consume custom newline string - verify each byte matches
+            for (let i = 0; i < this.newline.length; i++) {
+                const expectedByte = this.newline.charCodeAt(i);
+                const actualByte = this.byteBuffer.peek();
+                if (actualByte === null || actualByte !== expectedByte) {
+                    throw new Error('Invariant violation: consumeLineEnd called when not at line end');
+                }
+                this.byteBuffer.next();
+            }
+            this.endOfLineReached = true;
+        }
+        else {
+            // Default behavior: consume \r and/or \n
+            while (isLineEnd(this.byteBuffer.peek())) {
+                this.byteBuffer.next();
+                this.endOfLineReached = true;
+            }
+        }
+    }
     parse() {
         let str = '';
         for (const part of this) {
             str += part;
         }
-        return str;
+        return this.trim ? str.trim() : str;
     }
     async parseAsync() {
         let str = '';
         for await (const part of this) {
             str += part;
         }
-        return str;
+        return this.trim ? str.trim() : str;
     }
     /**
      * Reads the cell value and transforms it using the provided function.
@@ -209,22 +287,23 @@ export class CsvCell extends CsvEntity {
     *streamImpl() {
         const separator = this.separator.charCodeAt(0);
         const escapeChar = this.escapeChar.charCodeAt(0);
+        const quoteChar = this.quoteChar.charCodeAt(0);
         let chunk = [];
         let hadData = false;
-        let isEscaped = false;
+        let isQuoted = false;
         const next = this.byteBuffer.peek();
         if (next === null && this.byteBuffer.eof) {
             throw new Error('No more data to read');
         }
-        if (next === escapeChar) {
-            isEscaped = true;
-            this.byteBuffer.expect(escapeChar); // consume opening quote
+        if (next === quoteChar) {
+            isQuoted = true;
+            this.byteBuffer.expect(quoteChar); // consume opening quote
         }
         while (this.byteBuffer.peek() !== null) {
             const next = this.byteBuffer.peek();
-            if (isEscaped) {
-                if (next === escapeChar) {
-                    // Possible end of quoted cell
+            if (isQuoted) {
+                if (next === escapeChar && escapeChar === quoteChar) {
+                    // Standard CSV: quote char doubles as escape char
                     const lookahead = this.byteBuffer.peek(1);
                     if (lookahead === escapeChar) {
                         // Escaped quote
@@ -238,9 +317,23 @@ export class CsvCell extends CsvEntity {
                         break;
                     }
                 }
+                else if (next === quoteChar) {
+                    // End of quoted cell when using separate quote/escape chars
+                    break;
+                }
+                else if (next === escapeChar) {
+                    // Handle escape character when different from quote char
+                    const lookahead = this.byteBuffer.peek(1);
+                    if (lookahead !== null) {
+                        this.byteBuffer.expect(escapeChar); // consume escape char
+                        const escapedChar = this.byteBuffer.next(); // consume escaped char
+                        chunk.push(escapedChar);
+                        continue;
+                    }
+                }
             }
             else {
-                if (next === separator || isLineEnd(next)) {
+                if (next === separator || this.isAtLineEnd()) {
                     break;
                 }
             }
@@ -252,15 +345,14 @@ export class CsvCell extends CsvEntity {
                 hadData = true;
             }
         }
-        if (isEscaped) {
-            this.byteBuffer.expect(escapeChar); // consume closing quote
+        if (isQuoted) {
+            this.byteBuffer.expect(quoteChar); // consume closing quote
         }
         if (this.byteBuffer.peek() === separator) {
             this.byteBuffer.expect(separator); // consume separator
         }
-        while (isLineEnd(this.byteBuffer.peek())) {
-            this.byteBuffer.next(); // consume line ending
-            this.endOfLineReached = true;
+        if (this.isAtLineEnd()) {
+            this.consumeLineEnd();
         }
         if (!hadData || chunk.length > 0)
             yield bytesToString(new Uint8Array(chunk));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "csv-stream-lite",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "A lightweight, memory-efficient, zero-dependency streaming CSV parser and stringifier for JavaScript and TypeScript. It works in both Node.js and browser environments.",
   "main": "dist/index.js",
   "type": "module",