csv-stream-lite 1.0.2 → 1.0.3

package/dist/parser.d.ts

@@ -9,6 +9,8 @@ export interface CsvEntityOptions {
     separator?: string;
     /** Character used to escape special characters. Defaults to '"' */
     escapeChar?: string;
+    /** String used to denote new lines. Defaults to auto-detected '\r', '\n', or '\r\n' */
+    newline?: string;
 }
 /**
  * Abstract base class for CSV entities that supports both synchronous and asynchronous parsing.
@@ -17,10 +19,11 @@ 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;
+    newline?: string;
     consumed: boolean;
     /**
      * Creates a new CSV entity.
@@ -96,6 +99,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,7 @@ export class CsvEntity {
     byteBuffer;
     separator = ',';
     escapeChar = '"';
+    newline;
     consumed = false;
     /**
      * Creates a new CSV entity.
@@ -49,6 +50,19 @@ export class CsvEntity {
         if (options?.escapeChar) {
             this.escapeChar = options.escapeChar;
         }
+        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.');
+            }
+            this.newline = newline;
+        }
     }
     set maxBufferSize(size) {
         this.byteBuffer.maxBufferSize = size;
@@ -162,6 +176,55 @@ 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) {
@@ -240,7 +303,7 @@ export class CsvCell extends CsvEntity {
                 }
             }
             else {
-                if (next === separator || isLineEnd(next)) {
+                if (next === separator || this.isAtLineEnd()) {
                     break;
                 }
             }
@@ -258,9 +321,8 @@ export class CsvCell extends CsvEntity {
         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.3",
   "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",