jtcsv 2.1.3 → 2.2.2

package/src/browser/csv-to-json-browser.js

@@ -10,15 +10,10 @@ import {
 } from './errors-browser.js';
 
 /**
- * Валидация CSV ввода и опций
+ * Валидация опций парсинга
  * @private
  */
-function validateCsvInput(csv, options) {
-  // Validate CSV input
-  if (typeof csv !== 'string') {
-    throw new ValidationError('Input must be a CSV string');
-  }
-  
+function validateCsvOptions(options) {
   // Validate options
   if (options && typeof options !== 'object') {
     throw new ConfigurationError('Options must be an object');
@@ -47,10 +42,27 @@ function validateCsvInput(csv, options) {
   if (options?.maxRows !== undefined && (typeof options.maxRows !== 'number' || options.maxRows <= 0)) {
     throw new ConfigurationError('maxRows must be a positive number');
   }
+
+  if (options?.warnExtraFields !== undefined && typeof options.warnExtraFields !== 'boolean') {
+    throw new ConfigurationError('warnExtraFields must be a boolean');
+  }
   
   return true;
 }
 
+/**
+ * Валидация CSV ввода и опций
+ * @private
+ */
+function validateCsvInput(csv, options) {
+  // Validate CSV input
+  if (typeof csv !== 'string') {
+    throw new ValidationError('Input must be a CSV string');
+  }
+  
+  return validateCsvOptions(options);
+}
+
 /**
  * Парсинг одной строки CSV с правильным экранированием
  * @private
@@ -205,6 +217,95 @@ function parseCsvValue(value, options) {
   return result;
 }
 
+function isSimpleCsv(csv) {
+  return csv.indexOf('"') === -1 && csv.indexOf('\\') === -1;
+}
+
+function parseSimpleCsv(csv, delimiter, options) {
+  const {
+    hasHeaders = true,
+    renameMap = {},
+    trim = true,
+    parseNumbers = false,
+    parseBooleans = false,
+    maxRows
+  } = options;
+
+  const result = [];
+  let headers = null;
+  let fieldStart = 0;
+  let currentRow = [];
+  let rowHasData = false;
+  let rowCount = 0;
+
+  const finalizeRow = (fields) => {
+    if (fields.length === 1 && fields[0].trim() === '') {
+      return;
+    }
+
+    if (!headers) {
+      if (hasHeaders) {
+        headers = fields.map(header => {
+          const trimmed = trim ? header.trim() : header;
+          return renameMap[trimmed] || trimmed;
+        });
+        return;
+      }
+
+      headers = fields.map((_, index) => `column${index + 1}`);
+    }
+
+    rowCount++;
+    if (maxRows && rowCount > maxRows) {
+      throw new LimitError(
+        `CSV size exceeds maximum limit of ${maxRows} rows`,
+        maxRows,
+        rowCount
+      );
+    }
+
+    const row = {};
+    const fieldCount = Math.min(fields.length, headers.length);
+    for (let i = 0; i < fieldCount; i++) {
+      row[headers[i]] = parseCsvValue(fields[i], { trim, parseNumbers, parseBooleans });
+    }
+
+    result.push(row);
+  };
+
+  let i = 0;
+  while (i <= csv.length) {
+    const char = i < csv.length ? csv[i] : '\n';
+
+    if (char !== '\r' && char !== '\n' && char !== ' ' && char !== '\t') {
+      rowHasData = true;
+    }
+
+    if (char === delimiter || char === '\n' || char === '\r' || i === csv.length) {
+      const field = csv.slice(fieldStart, i);
+      currentRow.push(field);
+
+      if (char === '\n' || char === '\r' || i === csv.length) {
+        if (rowHasData || currentRow.length > 1) {
+          finalizeRow(currentRow);
+        }
+        currentRow = [];
+        rowHasData = false;
+      }
+
+      if (char === '\r' && csv[i + 1] === '\n') {
+        i++;
+      }
+
+      fieldStart = i + 1;
+    }
+
+    i++;
+  }
+
+  return result;
+}
+
 /**
  * Автоматическое определение разделителя CSV
  * 
@@ -285,7 +386,8 @@ export function csvToJson(csv, options = {}) {
       trim = true,
       parseNumbers = false,
       parseBooleans = false,
-      maxRows
+      maxRows,
+      warnExtraFields = true
     } = opts;
 
     // Определение разделителя
@@ -300,6 +402,17 @@ export function csvToJson(csv, options = {}) {
       return [];
     }
 
+    if (isSimpleCsv(csv)) {
+      return parseSimpleCsv(csv, finalDelimiter, {
+        hasHeaders,
+        renameMap,
+        trim,
+        parseNumbers,
+        parseBooleans,
+        maxRows
+      });
+    }
+
     // Парсинг CSV с обработкой кавычек и переносов строк
     const lines = [];
     let currentLine = '';
@@ -416,7 +529,8 @@ export function csvToJson(csv, options = {}) {
         }
         
         // Предупреждение о лишних полях
-        if (fields.length > headers.length && process.env.NODE_ENV === 'development') {
+        const isDev = typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'development';
+        if (fields.length > headers.length && warnExtraFields && isDev) {
           console.warn(`[jtcsv] Line ${i + 1}: ${fields.length - headers.length} extra fields ignored`);
         }
         
@@ -433,10 +547,154 @@ export function csvToJson(csv, options = {}) {
   }, 'PARSE_FAILED', { function: 'csvToJson' });
 }
 
+export async function* csvToJsonIterator(input, options = {}) {
+  const opts = options && typeof options === 'object' ? options : {};
+  validateCsvOptions(opts);
+
+  if (typeof input === 'string') {
+    const rows = csvToJson(input, options);
+    for (const row of rows) {
+      yield row;
+    }
+    return;
+  }
+
+  const {
+    delimiter,
+    autoDetect = true,
+    candidates = [';', ',', '\t', '|'],
+    hasHeaders = true,
+    renameMap = {},
+    trim = true,
+    parseNumbers = false,
+    parseBooleans = false,
+    maxRows
+  } = opts;
+
+  const stream = (input instanceof Blob && input.stream) ? input.stream() : input;
+  if (!stream || typeof stream.getReader !== 'function') {
+    throw new ValidationError('Input must be a CSV string, Blob/File, or ReadableStream');
+  }
+
+  const reader = stream.getReader();
+  const decoder = new TextDecoder('utf-8');
+  let buffer = '';
+  let insideQuotes = false;
+  let headers = null;
+  let rowCount = 0;
+  let lineNumber = 0;
+  let finalDelimiter = delimiter;
+  let delimiterResolved = Boolean(finalDelimiter);
+
+  const processFields = (fields) => {
+    if (fields.length === 1 && fields[0].trim() === '') {
+      return null;
+    }
+
+    rowCount++;
+    if (maxRows && rowCount > maxRows) {
+      throw new LimitError(
+        `CSV size exceeds maximum limit of ${maxRows} rows`,
+        maxRows,
+        rowCount
+      );
+    }
+
+    const row = {};
+    const fieldCount = Math.min(fields.length, headers.length);
+    for (let j = 0; j < fieldCount; j++) {
+      row[headers[j]] = parseCsvValue(fields[j], { trim, parseNumbers, parseBooleans });
+    }
+    return row;
+  };
+
+  const processLine = (line) => {
+    lineNumber++;
+    let cleanLine = line;
+    if (cleanLine.endsWith('\r')) {
+      cleanLine = cleanLine.slice(0, -1);
+    }
+
+    if (!delimiterResolved) {
+      if (!finalDelimiter && autoDetect) {
+        finalDelimiter = autoDetectDelimiter(cleanLine, candidates);
+      }
+      finalDelimiter = finalDelimiter || ';';
+      delimiterResolved = true;
+    }
+
+    if (cleanLine.trim() === '') {
+      return null;
+    }
+
+    if (!headers) {
+      if (hasHeaders) {
+        headers = parseCsvLine(cleanLine, lineNumber, finalDelimiter).map(header => {
+          const trimmed = trim ? header.trim() : header;
+          return renameMap[trimmed] || trimmed;
+        });
+        return null;
+      }
+
+      const fields = parseCsvLine(cleanLine, lineNumber, finalDelimiter);
+      headers = fields.map((_, index) => `column${index + 1}`);
+      return processFields(fields);
+    }
+
+    const fields = parseCsvLine(cleanLine, lineNumber, finalDelimiter);
+    return processFields(fields);
+  };
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) {
+      break;
+    }
+
+    buffer += decoder.decode(value, { stream: true });
+
+    let start = 0;
+    for (let i = 0; i < buffer.length; i++) {
+      const char = buffer[i];
+      if (char === '"') {
+        if (insideQuotes && buffer[i + 1] === '"') {
+          i++;
+          continue;
+        }
+        insideQuotes = !insideQuotes;
+        continue;
+      }
+
+      if (char === '\n' && !insideQuotes) {
+        const line = buffer.slice(start, i);
+        start = i + 1;
+        const row = processLine(line);
+        if (row) {
+          yield row;
+        }
+      }
+    }
+
+    buffer = buffer.slice(start);
+  }
+
+  if (buffer.length > 0) {
+    const row = processLine(buffer);
+    if (row) {
+      yield row;
+    }
+  }
+
+  if (insideQuotes) {
+    throw new ParsingError('Unclosed quotes in CSV', lineNumber);
+  }
+}
+
 // Экспорт для Node.js совместимости
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = {
     csvToJson,
-    autoDetectDelimiter
+    autoDetectDelimiter,
+    csvToJsonIterator
   };
-}
+}

package/src/browser/errors-browser.js

@@ -85,6 +85,23 @@ export class ConfigurationError extends JTCSVError {
   }
 }
 
+export const ERROR_CODES = {
+  JTCSV_ERROR: 'JTCSV_ERROR',
+  VALIDATION_ERROR: 'VALIDATION_ERROR',
+  SECURITY_ERROR: 'SECURITY_ERROR',
+  FILE_SYSTEM_ERROR: 'FILE_SYSTEM_ERROR',
+  PARSING_ERROR: 'PARSING_ERROR',
+  LIMIT_ERROR: 'LIMIT_ERROR',
+  CONFIGURATION_ERROR: 'CONFIGURATION_ERROR',
+  INVALID_INPUT: 'INVALID_INPUT',
+  SECURITY_VIOLATION: 'SECURITY_VIOLATION',
+  FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+  PARSE_FAILED: 'PARSE_FAILED',
+  SIZE_LIMIT: 'SIZE_LIMIT',
+  INVALID_CONFIG: 'INVALID_CONFIG',
+  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+};
+
 /**
  * Безопасное выполнение функции с обработкой ошибок
  * 
@@ -188,7 +205,8 @@ if (typeof module !== 'undefined' && module.exports) {
     ParsingError,
     LimitError,
     ConfigurationError,
+    ERROR_CODES,
     safeExecute,
     safeExecuteAsync
   };
-}
+}

package/src/browser/index.js

@@ -2,8 +2,15 @@
 // Экспортирует все функции с поддержкой браузера
 
 import { jsonToCsv, preprocessData, deepUnwrap } from './json-to-csv-browser.js';
-import { csvToJson, autoDetectDelimiter } from './csv-to-json-browser.js';
-import { downloadAsCsv, parseCsvFile } from './browser-functions.js';
+import { csvToJson, csvToJsonIterator, autoDetectDelimiter } from './csv-to-json-browser.js';
+import {
+  downloadAsCsv,
+  parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream
+} from './browser-functions.js';
 import { createWorkerPool, parseCSVWithWorker } from './workers/worker-pool.js';
 import {
   ValidationError,
@@ -11,9 +18,20 @@ import {
   FileSystemError,
   ParsingError,
   LimitError,
-  ConfigurationError
+  ConfigurationError,
+  ERROR_CODES
 } from './errors-browser.js';
 
+async function createWorkerPoolLazy(options = {}) {
+  const mod = await import('./workers/worker-pool.js');
+  return mod.createWorkerPool(options);
+}
+
+async function parseCSVWithWorkerLazy(csvInput, options = {}, onProgress = null) {
+  const mod = await import('./workers/worker-pool.js');
+  return mod.parseCSVWithWorker(csvInput, options, onProgress);
+}
+
 // Основной экспорт
 const jtcsv = {
   // JSON to CSV функции
@@ -24,12 +42,19 @@ const jtcsv = {
   
   // CSV to JSON функции
   csvToJson,
+  csvToJsonIterator,
   parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream,
   autoDetectDelimiter,
   
   // Web Workers функции
   createWorkerPool,
   parseCSVWithWorker,
+  createWorkerPoolLazy,
+  parseCSVWithWorkerLazy,
   
   // Error classes
   ValidationError,
@@ -38,6 +63,7 @@ const jtcsv = {
   ParsingError,
   LimitError,
   ConfigurationError,
+  ERROR_CODES,
   
   // Удобные алиасы
   parse: csvToJson,
@@ -66,14 +92,22 @@ export {
   downloadAsCsv,
   deepUnwrap,
   csvToJson,
+  csvToJsonIterator,
   parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream,
   autoDetectDelimiter,
   createWorkerPool,
   parseCSVWithWorker,
+  createWorkerPoolLazy,
+  parseCSVWithWorkerLazy,
   ValidationError,
   SecurityError,
   FileSystemError,
   ParsingError,
   LimitError,
-  ConfigurationError
-};
+  ConfigurationError,
+  ERROR_CODES
+};