jtcsv 2.1.0 → 2.1.3

package/examples/simple-usage.js

@@ -238,8 +238,8 @@ try {
   console.log('  examples/plugin-excel-exporter.js');
 } catch (error) {
   console.log('⚠️  Полная интеграция требует дополнительных зависимостей');
-  console.log('Установите exceljs для демонстрации Excel плагина:');
-  console.log('  npm install exceljs --save-optional');
+  console.log('Установите @jtcsv/excel и exceljs для демонстрации Excel плагина:');
+  console.log('  npm install @jtcsv/excel exceljs');
 }
 
 // ============================================================================
@@ -277,4 +277,3 @@ console.log('✨  JTCSV 2.1.0 - Next Generation JSON/CSV Converter  ✨');
 console.log('✨'.repeat(30));
 
 
-

package/index.d.ts

@@ -44,6 +44,10 @@ declare module 'jtcsv' {
     parseBooleans?: boolean;
     /** Maximum number of rows to process (optional, no limit by default) */
     maxRows?: number;
+    /** Enable fast-path parsing (default: true) */
+    useFastPath?: boolean;
+    /** Fast-path output mode (default: 'objects') */
+    fastPathMode?: 'objects' | 'compact' | 'stream';
   }
 
   // JSON save interfaces
@@ -71,6 +75,99 @@ declare module 'jtcsv' {
     schema?: Record<string, any>;
   }
 
+  // NDJSON interfaces
+  export interface NdjsonOptions {
+    /** Buffer size for streaming (default: 64KB) */
+    bufferSize?: number;
+    /** Maximum line length (default: 10MB) */
+    maxLineLength?: number;
+    /** Error handler callback */
+    onError?: (error: Error, line: string, lineNumber: number) => void;
+    /** JSON stringify replacer function */
+    replacer?: (key: string, value: any) => any;
+    /** JSON stringify space (indentation) */
+    space?: number | string;
+    /** Filter function for rows */
+    filter?: (obj: Record<string, any>, index: number) => boolean;
+    /** Transform function for rows */
+    transform?: (obj: Record<string, any>, index: number) => any;
+  }
+
+  export interface NdjsonToCsvStreamOptions {
+    /** Delimiter for CSV output (default: ',') */
+    delimiter?: string;
+    /** Include headers row (default: true) */
+    includeHeaders?: boolean;
+  }
+
+  export interface CsvToNdjsonStreamOptions {
+    /** Delimiter for CSV input (default: ',') */
+    delimiter?: string;
+    /** Whether CSV has headers (default: true) */
+    hasHeaders?: boolean;
+  }
+
+  export interface NdjsonStats {
+    /** Total lines in NDJSON */
+    totalLines: number;
+    /** Valid JSON lines */
+    validLines: number;
+    /** Lines with JSON parsing errors */
+    errorLines: number;
+    /** Total bytes */
+    totalBytes: number;
+    /** Success rate percentage */
+    successRate: number;
+    /** Array of parsing errors */
+    errors: Array<{
+      line: number;
+      error: string;
+      content: string;
+    }>;
+  }
+
+  // TSV interfaces
+  export interface TsvOptions extends JsonToCsvOptions, CsvToJsonOptions {
+    /** Always use tab as delimiter for TSV */
+    delimiter?: '\t';
+    /** Disable auto-detection for TSV */
+    autoDetect?: false;
+  }
+
+  export interface ValidateTsvOptions {
+    /** Require consistent column count (default: true) */
+    requireConsistentColumns?: boolean;
+    /** Disallow empty fields (default: false) */
+    disallowEmptyFields?: boolean;
+  }
+
+  export interface TsvValidationResult {
+    /** Whether TSV is valid */
+    valid: boolean;
+    /** Error message if invalid */
+    error?: string;
+    /** Validation statistics */
+    stats: {
+      /** Total lines */
+      totalLines: number;
+      /** Total columns in first line */
+      totalColumns: number;
+      /** Minimum columns across all lines */
+      minColumns: number;
+      /** Maximum columns across all lines */
+      maxColumns: number;
+      /** Whether all lines have same column count */
+      consistentColumns: boolean;
+    };
+    /** Array of validation errors */
+    errors?: Array<{
+      line?: number;
+      error: string;
+      details?: any;
+      fields?: number[];
+    }>;
+  }
+
   // Error classes
   export class JtcsvError extends Error {
     code: string;
@@ -182,10 +279,31 @@ declare module 'jtcsv' {
    * @throws {LimitError} If row limit exceeded
    */
   export function csvToJson(
-    csv: string, 
+    csv: string,
+    options: CsvToJsonOptions & { fastPathMode: 'stream' }
+  ): AsyncGenerator<Record<string, any> | any[]>;
+
+  export function csvToJson(
+    csv: string,
+    options: CsvToJsonOptions & { fastPathMode: 'compact' }
+  ): any[][];
+
+  export function csvToJson(
+    csv: string,
     options?: CsvToJsonOptions
   ): Record<string, any>[];
 
+  /**
+   * Convert CSV string to JSON rows as async iterator
+   * @param csv CSV string to convert
+   * @param options Conversion options
+   * @returns Async generator yielding rows
+   */
+  export function csvToJsonIterator(
+    csv: string,
+    options?: CsvToJsonOptions
+  ): AsyncGenerator<Record<string, any> | any[]>;
+
   /**
    * Read CSV file and convert it to JSON array
    * @param filePath Path to CSV file
@@ -360,8 +478,173 @@ declare module 'jtcsv' {
    * @returns Writable stream that collects data
    */
   export function createJsonCollectorStream(): Writable;
+
+  // NDJSON format support
+
+  /**
+   * Convert JSON array to NDJSON string
+   * @param data Array of objects to convert
+   * @param options NDJSON options
+   * @returns NDJSON string
+   */
+  export function jsonToNdjson<T extends Record<string, any>>(
+    data: T[],
+    options?: NdjsonOptions
+  ): string;
+
+  /**
+   * Convert NDJSON string to JSON array
+   * @param ndjsonString NDJSON string
+   * @param options NDJSON options
+   * @returns JSON array
+   */
+  export function ndjsonToJson(
+    ndjsonString: string,
+    options?: NdjsonOptions
+  ): Record<string, any>[];
+
+  /**
+   * Parse NDJSON stream as async iterator
+   * @param input ReadableStream or string input
+   * @param options NDJSON options
+   * @returns Async generator of JSON objects
+   */
+  export function parseNdjsonStream(
+    input: ReadableStream | string,
+    options?: NdjsonOptions
+  ): AsyncGenerator<Record<string, any>>;
+
+  /**
+   * Create TransformStream for converting NDJSON to CSV
+   * @param options Conversion options
+   * @returns TransformStream
+   */
+  export function createNdjsonToCsvStream(
+    options?: NdjsonToCsvStreamOptions
+  ): TransformStream;
+
+  /**
+   * Create TransformStream for converting CSV to NDJSON
+   * @param options Conversion options
+   * @returns TransformStream
+   */
+  export function createCsvToNdjsonStream(
+    options?: CsvToNdjsonStreamOptions
+  ): TransformStream;
+
+  /**
+   * Get statistics for NDJSON data
+   * @param input NDJSON string or ReadableStream
+   * @returns Promise with NDJSON statistics
+   */
+  export function getNdjsonStats(
+    input: string | ReadableStream
+  ): Promise<NdjsonStats>;
+
+  // TSV format support
+
+  /**
+   * Convert JSON array to TSV string
+   * @param data Array of objects to convert
+   * @param options TSV options
+   * @returns TSV string
+   */
+  export function jsonToTsv<T extends Record<string, any>>(
+    data: T[],
+    options?: TsvOptions
+  ): string;
+
+  /**
+   * Convert TSV string to JSON array
+   * @param tsvString TSV string
+   * @param options TSV options
+   * @returns JSON array
+   */
+  export function tsvToJson(
+    tsvString: string,
+    options?: TsvOptions
+  ): Record<string, any>[];
+
+  /**
+   * Check if string is likely TSV format
+   * @param sample Sample data string
+   * @returns True if likely TSV format
+   */
+  export function isTsv(sample: string): boolean;
+
+  /**
+   * Validate TSV string structure
+   * @param tsvString TSV string to validate
+   * @param options Validation options
+   * @returns Validation result
+   */
+  export function validateTsv(
+    tsvString: string,
+    options?: ValidateTsvOptions
+  ): TsvValidationResult;
+
+  /**
+   * Read TSV file and convert to JSON array
+   * @param filePath Path to TSV file
+   * @param options TSV options
+   * @returns Promise with JSON array
+   */
+  export function readTsvAsJson(
+    filePath: string,
+    options?: TsvOptions
+  ): Promise<Record<string, any>[]>;
+
+  /**
+   * Synchronously read TSV file and convert to JSON array
+   * @param filePath Path to TSV file
+   * @param options TSV options
+   * @returns JSON array
+   */
+  export function readTsvAsJsonSync(
+    filePath: string,
+    options?: TsvOptions
+  ): Record<string, any>[];
+
+  /**
+   * Save JSON data as TSV file
+   * @param data Array of objects to save
+   * @param filePath Output file path
+   * @param options TSV options
+   * @returns Promise that resolves when file is saved
+   */
+  export function saveAsTsv<T extends Record<string, any>>(
+    data: T[],
+    filePath: string,
+    options?: TsvOptions
+  ): Promise<void>;
+
+  /**
+   * Synchronously save JSON data as TSV file
+   * @param data Array of objects to save
+   * @param filePath Output file path
+   * @param options TSV options
+   */
+  export function saveAsTsvSync<T extends Record<string, any>>(
+    data: T[],
+    filePath: string,
+    options?: TsvOptions
+  ): void;
+
+  /**
+   * Create TransformStream for converting JSON to TSV
+   * @param options TSV options
+   * @returns TransformStream
+   */
+  export function createJsonToTsvStream(
+    options?: TsvOptions
+  ): TransformStream;
+
+  /**
+   * Create TransformStream for converting TSV to JSON
+   * @param options TSV options
+   * @returns TransformStream
+   */
+  export function createTsvToJsonStream(
+    options?: TsvOptions
+  ): TransformStream;
 }
-
-
-
-

package/index.js

@@ -7,6 +7,8 @@ const errorsModule = require('./errors');
 const jsonSaveModule = require('./json-save');
 const streamJsonToCsvModule = require('./stream-json-to-csv');
 const streamCsvToJsonModule = require('./stream-csv-to-json');
+const ndjsonParser = require('./src/formats/ndjson-parser');
+const tsvParser = require('./src/formats/tsv-parser');
 
 // Combine all exports
 module.exports = {
@@ -19,6 +21,7 @@ module.exports = {
   
   // CSV to JSON functions
   csvToJson: csvToJsonModule.csvToJson,
+  csvToJsonIterator: csvToJsonModule.csvToJsonIterator,
   readCsvAsJson: csvToJsonModule.readCsvAsJson,
   readCsvAsJsonSync: csvToJsonModule.readCsvAsJsonSync,
   autoDetectDelimiter: csvToJsonModule.autoDetectDelimiter,
@@ -40,6 +43,26 @@ module.exports = {
   createCsvFileToJsonStream: streamCsvToJsonModule.createCsvFileToJsonStream,
   createJsonCollectorStream: streamCsvToJsonModule.createJsonCollectorStream,
 
+  // NDJSON format support
+  jsonToNdjson: ndjsonParser.toNdjson,
+  ndjsonToJson: ndjsonParser.fromNdjson,
+  parseNdjsonStream: ndjsonParser.parseStream,
+  createNdjsonToCsvStream: ndjsonParser.createNdjsonToCsvStream,
+  createCsvToNdjsonStream: ndjsonParser.createCsvToNdjsonStream,
+  getNdjsonStats: ndjsonParser.getStats,
+
+  // TSV format support
+  jsonToTsv: tsvParser.jsonToTsv,
+  tsvToJson: tsvParser.tsvToJson,
+  isTsv: tsvParser.isTsv,
+  validateTsv: tsvParser.validateTsv,
+  readTsvAsJson: tsvParser.readTsvAsJson,
+  readTsvAsJsonSync: tsvParser.readTsvAsJsonSync,
+  saveAsTsv: tsvParser.saveAsTsv,
+  saveAsTsvSync: tsvParser.saveAsTsvSync,
+  createJsonToTsvStream: tsvParser.createJsonToTsvStream,
+  createTsvToJsonStream: tsvParser.createTsvToJsonStream,
+
   // Error classes
   ...errorsModule
 };

package/json-to-csv.js

@@ -135,35 +135,68 @@ function jsonToCsv(data, options = {}) {
       );
     }
 
-    // Get all unique keys from all objects
-    const allKeys = new Set();
-    data.forEach((item) => {
-      if (!item || typeof item !== 'object') {
-        return;
-      }
-      Object.keys(item).forEach(key => allKeys.add(key));
-    });
-    
-    // Convert Set to Array
-    const originalKeys = Array.from(allKeys);
-    
-    // Apply rename map to create header names
-    const headers = originalKeys.map(key => renameMap[key] || key);
-    
-    // Create a reverse mapping from new header to original key
-    const reverseRenameMap = {};
-    originalKeys.forEach((key, index) => {
-      reverseRenameMap[headers[index]] = key;
-    });
-
-    // Apply template ordering if provided
-    let finalHeaders = headers;
-    if (Object.keys(template).length > 0) {
-      // Create template headers with renaming applied
-      const templateHeaders = Object.keys(template).map(key => renameMap[key] || key);
-      const extraHeaders = headers.filter(h => !templateHeaders.includes(h));
-      finalHeaders = [...templateHeaders, ...extraHeaders];
-    }
+    // Get all unique keys from all objects with minimal allocations.
+    const allKeys = new Set();
+    const originalKeys = [];
+    for (let i = 0; i < data.length; i++) {
+      const item = data[i];
+      if (!item || typeof item !== 'object') {
+        continue;
+      }
+      for (const key in item) {
+        if (Object.prototype.hasOwnProperty.call(item, key) && !allKeys.has(key)) {
+          allKeys.add(key);
+          originalKeys.push(key);
+        }
+      }
+    }
+
+    const hasRenameMap = Object.keys(renameMap).length > 0;
+    const hasTemplate = Object.keys(template).length > 0;
+
+    // Apply rename map to create header names.
+    let headers = originalKeys;
+    let reverseRenameMap = null;
+    if (hasRenameMap) {
+      headers = new Array(originalKeys.length);
+      reverseRenameMap = {};
+      for (let i = 0; i < originalKeys.length; i++) {
+        const key = originalKeys[i];
+        const header = renameMap[key] || key;
+        headers[i] = header;
+        reverseRenameMap[header] = key;
+      }
+    }
+
+    // Apply template ordering if provided.
+    let finalHeaders = headers;
+    if (hasTemplate) {
+      const templateKeys = Object.keys(template);
+      const templateHeaders = hasRenameMap
+        ? templateKeys.map(key => renameMap[key] || key)
+        : templateKeys;
+      const templateHeaderSet = new Set(templateHeaders);
+      const extraHeaders = [];
+      for (let i = 0; i < headers.length; i++) {
+        const header = headers[i];
+        if (!templateHeaderSet.has(header)) {
+          extraHeaders.push(header);
+        }
+      }
+      finalHeaders = templateHeaders.concat(extraHeaders);
+    }
+
+    const finalKeys = new Array(finalHeaders.length);
+    if (hasRenameMap) {
+      for (let i = 0; i < finalHeaders.length; i++) {
+        const header = finalHeaders[i];
+        finalKeys[i] = reverseRenameMap[header] || header;
+      }
+    } else {
+      for (let i = 0; i < finalHeaders.length; i++) {
+        finalKeys[i] = finalHeaders[i];
+      }
+    }
 
     /**
      * Escapes a value for CSV format with CSV injection protection
@@ -172,67 +205,75 @@ function jsonToCsv(data, options = {}) {
      * @param {*} value - The value to escape
      * @returns {string} Escaped CSV value
      */
-    const escapeValue = (value) => {
-      if (value === null || value === undefined || value === '') {
-        return '';
-      }
-      
-      const stringValue = String(value);
-      
-      // CSV Injection protection - escape formulas if enabled
-      let escapedValue = stringValue;
-      if (preventCsvInjection && /^[=+\-@]/.test(stringValue)) {
-        // Prepend single quote to prevent formula execution in Excel
-        escapedValue = "'" + stringValue;
-      }
-      
-      // RFC 4180 compliance: fields containing line breaks, double quotes, or commas must be quoted
-      const needsQuoting = rfc4180Compliant 
-        ? (escapedValue.includes(delimiter) ||
-           escapedValue.includes('"') ||
-           escapedValue.includes('\n') ||
-           escapedValue.includes('\r'))
-        : (escapedValue.includes(delimiter) ||
-           escapedValue.includes('"') ||
-           escapedValue.includes('\n') ||
-           escapedValue.includes('\r'));
-      
-      if (needsQuoting) {
-        // RFC 4180: If double-quotes are used to enclose fields, then a double-quote 
-        // appearing inside a field must be escaped by preceding it with another double quote.
-        return `"${escapedValue.replace(/"/g, '""')}"`;
-      }
-      
-      return escapedValue;
-    };
+    const quoteRegex = /"/g;
+    const delimiterCode = delimiter.charCodeAt(0);
+
+    const escapeValue = (value) => {
+      if (value === null || value === undefined || value === '') {
+        return '';
+      }
+      
+      let stringValue = value;
+      if (typeof stringValue !== 'string') {
+        stringValue = String(stringValue);
+      }
+      
+      // CSV Injection protection - escape formulas if enabled
+      let escapedValue = stringValue;
+      if (preventCsvInjection) {
+        const firstCharCode = stringValue.charCodeAt(0);
+        if (firstCharCode === 61 || firstCharCode === 43 || firstCharCode === 45 || firstCharCode === 64) {
+          escapedValue = "'" + stringValue;
+        }
+      }
+
+      let needsQuoting = false;
+      let hasQuote = false;
+      for (let i = 0; i < escapedValue.length; i++) {
+        const code = escapedValue.charCodeAt(i);
+        if (code === 34) {
+          hasQuote = true;
+          needsQuoting = true;
+        } else if (code === delimiterCode || code === 10 || code === 13) {
+          needsQuoting = true;
+        }
+      }
+
+      if (needsQuoting) {
+        const quotedValue = hasQuote ? escapedValue.replace(quoteRegex, '""') : escapedValue;
+        return `"${quotedValue}"`;
+      }
+
+      return escapedValue;
+    };
 
-    // Build CSV rows
-    const rows = [];
-    
-    // Add headers row if requested
-    if (includeHeaders && finalHeaders.length > 0) {
-      rows.push(finalHeaders.join(delimiter));
-    }
-    
-    // Add data rows
-    for (const item of data) {
-      if (!item || typeof item !== 'object') {
-        continue;
-      }
-      
-      const row = finalHeaders.map(header => {
-        // Get the original key for this header
-        const originalKey = reverseRenameMap[header] || header;
-        const value = item[originalKey];
-        return escapeValue(value);
-      }).join(delimiter);
-      
-      rows.push(row);
-    }
-    
-    // RFC 4180: Each record is located on a separate line, delimited by a line break (CRLF)
-    const lineEnding = rfc4180Compliant ? '\r\n' : '\n';
-    return rows.join(lineEnding);
+    // Build CSV rows.
+    const rows = [];
+    const columnCount = finalHeaders.length;
+
+    // Add headers row if requested.
+    if (includeHeaders && columnCount > 0) {
+      rows.push(finalHeaders.join(delimiter));
+    }
+
+    // Add data rows.
+    const rowValues = new Array(columnCount);
+    for (let rowIndex = 0; rowIndex < data.length; rowIndex++) {
+      const item = data[rowIndex];
+      if (!item || typeof item !== 'object') {
+        continue;
+      }
+
+      for (let i = 0; i < columnCount; i++) {
+        rowValues[i] = escapeValue(item[finalKeys[i]]);
+      }
+
+      rows.push(rowValues.join(delimiter));
+    }
+
+    // RFC 4180: Each record is located on a separate line, delimited by a line break (CRLF).
+    const lineEnding = rfc4180Compliant ? '\r\n' : '\n';
+    return rows.join(lineEnding);
   }, 'PARSE_FAILED', { function: 'jsonToCsv' });
 }