jtcsv 2.2.7 → 3.0.0

package/src/browser/streams.ts

@@ -0,0 +1,336 @@
+import {
+  ValidationError,
+  ConfigurationError,
+  LimitError
+} from './errors-browser';
+import { csvToJsonIterator } from './csv-to-json-browser';
+
+import type { CsvToJsonOptions, JsonToCsvOptions } from '../types';
+
+const DEFAULT_MAX_CHUNK_SIZE = 64 * 1024;
+
+function isReadableStream(value: any): value is ReadableStream {
+  return value && typeof value.getReader === 'function';
+}
+
+function isAsyncIterable(value: any): value is AsyncIterable<any> {
+  return value && typeof value[Symbol.asyncIterator] === 'function';
+}
+
+function isIterable(value: any): value is Iterable<any> {
+  return value && typeof value[Symbol.iterator] === 'function';
+}
+
+function createReadableStreamFromIterator<T>(iterator: AsyncIterator<T>): ReadableStream<T> {
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel() {
+      if (iterator.return) {
+        iterator.return();
+      }
+    }
+  });
+}
+
+function detectInputFormat(input: any, options: any): 'json' | 'ndjson' | 'csv' | 'unknown' {
+  if (options && options.inputFormat) {
+    return options.inputFormat;
+  }
+
+  if (typeof input === 'string') {
+    const trimmed = input.trim();
+    if (trimmed === '') {
+      return 'unknown';
+    }
+
+    // Проверка на NDJSON (каждая строка - валидный JSON)
+    if (trimmed.includes('\n')) {
+      const lines = trimmed.split('\n').filter(line => line.trim() !== '');
+      if (lines.length > 0) {
+        try {
+          JSON.parse(lines[0]);
+          return 'ndjson';
+        } catch {
+          // Не NDJSON
+        }
+      }
+    }
+
+    // Проверка на JSON
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed) || (parsed && typeof parsed === 'object')) {
+        return 'json';
+      }
+    } catch {
+      // Не JSON
+    }
+
+    // Проверка на CSV
+    if (trimmed.includes(',') || trimmed.includes(';') || trimmed.includes('\t')) {
+      return 'csv';
+    }
+  }
+
+  return 'unknown';
+}
+
+async function* jsonToCsvChunkIterator(input: any, options: JsonToCsvOptions = {}): AsyncGenerator<string> {
+  const format = detectInputFormat(input, options);
+  
+  if (format === 'csv') {
+    throw new ValidationError('Input appears to be CSV, not JSON');
+  }
+
+  // Вспомогательная функция для создания асинхронного итератора
+  function toAsyncIterator<T>(iterable: Iterable<T> | AsyncIterable<T>): AsyncIterator<T> {
+    if (isAsyncIterable(iterable)) {
+      return iterable[Symbol.asyncIterator]();
+    }
+    
+    if (isIterable(iterable)) {
+      const syncIterator = iterable[Symbol.iterator]();
+      return {
+        next: () => Promise.resolve(syncIterator.next()),
+        return: syncIterator.return ? () => Promise.resolve(syncIterator.return!()) : undefined,
+        throw: syncIterator.throw ? (error: any) => Promise.resolve(syncIterator.throw!(error)) : undefined
+      };
+    }
+    
+    throw new ValidationError('Input is not iterable');
+  }
+
+  let iterator: AsyncIterator<any>;
+  
+  if (isAsyncIterable(input) || isIterable(input)) {
+    iterator = toAsyncIterator(input);
+  } else if (typeof input === 'string') {
+    const parsed = JSON.parse(input);
+    if (Array.isArray(parsed)) {
+      iterator = toAsyncIterator(parsed);
+    } else {
+      iterator = toAsyncIterator([parsed]);
+    }
+  } else if (Array.isArray(input)) {
+    iterator = toAsyncIterator(input);
+  } else {
+    iterator = toAsyncIterator([input]);
+  }
+
+  const delimiter = options.delimiter || ';';
+  const includeHeaders = options.includeHeaders !== false;
+  const preventInjection = options.preventCsvInjection !== false;
+  
+  let isFirstChunk = true;
+  let headers: string[] = [];
+  
+  while (true) {
+    const { value, done } = await iterator.next();
+    if (done) break;
+
+    const item = value;
+    
+    if (isFirstChunk) {
+      // Извлечение заголовков из первого элемента
+      headers = Object.keys(item);
+      
+      if (includeHeaders) {
+        const headerLine = headers.map(header => {
+          const escaped = header.includes('"') ? `"${header.replace(/"/g, '""')}"` : header;
+          return preventInjection && /^[=+\-@]/.test(escaped) ? `'${escaped}` : escaped;
+        }).join(delimiter);
+        
+        yield headerLine + '\n';
+      }
+      
+      isFirstChunk = false;
+    }
+    
+    const row = headers.map(header => {
+      const value = item[header];
+      const strValue = value === null || value === undefined ? '' : String(value);
+      
+      if (strValue.includes('"') || strValue.includes('\n') || strValue.includes('\r') || strValue.includes(delimiter)) {
+        return `"${strValue.replace(/"/g, '""')}"`;
+      }
+      
+      if (preventInjection && /^[=+\-@]/.test(strValue)) {
+        return `'${strValue}`;
+      }
+      
+      return strValue;
+    }).join(delimiter);
+    
+    yield row + '\n';
+  }
+}
+
+async function* jsonToNdjsonChunkIterator(input: any, options: any = {}): AsyncGenerator<string> {
+  const format = detectInputFormat(input, options);
+  
+  // Вспомогательная функция для создания асинхронного итератора
+  function toAsyncIterator<T>(iterable: Iterable<T> | AsyncIterable<T>): AsyncIterator<T> {
+    if (isAsyncIterable(iterable)) {
+      return iterable[Symbol.asyncIterator]();
+    }
+    
+    if (isIterable(iterable)) {
+      const syncIterator = iterable[Symbol.iterator]();
+      return {
+        next: () => Promise.resolve(syncIterator.next()),
+        return: syncIterator.return ? () => Promise.resolve(syncIterator.return!()) : undefined,
+        throw: syncIterator.throw ? (error: any) => Promise.resolve(syncIterator.throw!(error)) : undefined
+      };
+    }
+    
+    throw new ValidationError('Input is not iterable');
+  }
+
+  let iterator: AsyncIterator<any>;
+  
+  if (isAsyncIterable(input) || isIterable(input)) {
+    iterator = toAsyncIterator(input);
+  } else if (typeof input === 'string') {
+    if (format === 'ndjson') {
+      const lines = input.split('\n').filter(line => line.trim() !== '');
+      iterator = toAsyncIterator(lines);
+    } else {
+      const parsed = JSON.parse(input);
+      if (Array.isArray(parsed)) {
+        iterator = toAsyncIterator(parsed);
+      } else {
+        iterator = toAsyncIterator([parsed]);
+      }
+    }
+  } else if (Array.isArray(input)) {
+    iterator = toAsyncIterator(input);
+  } else {
+    iterator = toAsyncIterator([input]);
+  }
+
+  while (true) {
+    const { value, done } = await iterator.next();
+    if (done) break;
+
+    let jsonStr: string;
+    
+    if (typeof value === 'string') {
+      try {
+        // Проверяем, является ли строка валидным JSON
+        JSON.parse(value);
+        jsonStr = value;
+      } catch {
+        // Если нет, сериализуем как JSON
+        jsonStr = JSON.stringify(value);
+      }
+    } else {
+      jsonStr = JSON.stringify(value);
+    }
+    
+    yield jsonStr + '\n';
+  }
+}
+
+async function* csvToJsonChunkIterator(input: any, options: CsvToJsonOptions = {}): AsyncGenerator<any> {
+  if (typeof input === 'string') {
+    // Используем csvToJsonIterator из csv-to-json-browser
+    yield* csvToJsonIterator(input, options);
+  } else if (input instanceof File || input instanceof Blob) {
+    const text = await input.text();
+    yield* csvToJsonIterator(text, options);
+  } else if (isReadableStream(input)) {
+    const reader = input.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        
+        buffer += decoder.decode(value, { stream: true });
+        
+        // Обработка буфера по строкам
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        
+        // TODO: Реализовать парсинг CSV из чанков
+        // Пока просто возвращаем сырые строки
+        for (const line of lines) {
+          if (line.trim()) {
+            yield { raw: line };
+          }
+        }
+      }
+      
+      // Обработка остатка буфера
+      if (buffer.trim()) {
+        yield { raw: buffer };
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  } else {
+    throw new ValidationError('Unsupported input type for CSV streaming');
+  }
+}
+
+export function jsonToCsvStream(input: any, options: JsonToCsvOptions = {}): ReadableStream<string> {
+  const iterator = jsonToCsvChunkIterator(input, options);
+  return createReadableStreamFromIterator(iterator);
+}
+
+export function jsonToNdjsonStream(input: any, options: any = {}): ReadableStream<string> {
+  const iterator = jsonToNdjsonChunkIterator(input, options);
+  return createReadableStreamFromIterator(iterator);
+}
+
+export function csvToJsonStream(input: any, options: CsvToJsonOptions = {}): ReadableStream<any> {
+  const iterator = csvToJsonChunkIterator(input, options);
+  return createReadableStreamFromIterator(iterator);
+}
+
+/**
+ * Асинхронная версия jsonToCsvStream
+ */
+export async function jsonToCsvStreamAsync(input: any, options: JsonToCsvOptions = {}): Promise<ReadableStream<string>> {
+  return jsonToCsvStream(input, options);
+}
+
+/**
+ * Асинхронная версия jsonToNdjsonStream
+ */
+export async function jsonToNdjsonStreamAsync(input: any, options: any = {}): Promise<ReadableStream<string>> {
+  return jsonToNdjsonStream(input, options);
+}
+
+/**
+ * Асинхронная версия csvToJsonStream
+ */
+export async function csvToJsonStreamAsync(input: any, options: CsvToJsonOptions = {}): Promise<ReadableStream<any>> {
+  return csvToJsonStream(input, options);
+}
+
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    jsonToCsvStream,
+    jsonToCsvStreamAsync,
+    jsonToNdjsonStream,
+    jsonToNdjsonStreamAsync,
+    csvToJsonStream,
+    csvToJsonStreamAsync,
+    createReadableStreamFromIterator
+  };
+}

package/src/browser/workers/csv-parser.worker.ts

@@ -0,0 +1,377 @@
+// Web Worker для обработки CSV
+// Работает в отдельном потоке, не блокируя основной
+
+// Импорт функций парсинга (они будут bundled вместе с worker)
+import { csvToJson } from '../csv-to-json-browser';
+import { jsonToCsv } from '../json-to-csv-browser';
+
+const textDecoder = new TextDecoder('utf-8');
+
+// Кеш для повторного использования результатов
+const cache = new Map();
+const CACHE_MAX_SIZE = 50;
+const CACHE_TTL = 5 * 60 * 1000; // 5 минут
+
+// Статистика worker
+const stats = {
+  tasksProcessed: 0,
+  cacheHits: 0,
+  cacheMisses: 0,
+  totalProcessingTime: 0,
+  averageProcessingTime: 0
+};
+
+/**
+ * Генерация ключа кеша для CSV строки
+ * @param {string} csv - CSV строка
+ * @param {Object} options - Опции парсинга
+ * @returns {string} Ключ кеша
+ */
+function generateCacheKey(csv, options) {
+  // Простой хэш для CSV строки
+  let hash = 0;
+  for (let i = 0; i < csv.length; i++) {
+    const char = csv.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash; // Convert to 32bit integer
+  }
+  
+  // Добавление опций в хэш
+  const optionsStr = JSON.stringify(options);
+  for (let i = 0; i < optionsStr.length; i++) {
+    const char = optionsStr.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash;
+  }
+  
+  return `csv-${hash.toString(36)}-${optionsStr.length}`;
+}
+
+/**
+ * Очистка устаревших записей кеша
+ */
+function cleanupCache() {
+  const now = Date.now();
+  for (const [key, entry] of cache.entries()) {
+    if (now - entry.timestamp > CACHE_TTL) {
+      cache.delete(key);
+    }
+  }
+  
+  // Ограничение размера кеша
+  if (cache.size > CACHE_MAX_SIZE) {
+    const oldestKey = Array.from(cache.entries())
+      .sort((a, b) => a[1].timestamp - b[1].timestamp)[0][0];
+    cache.delete(oldestKey);
+  }
+}
+
+/**
+ * Парсинг CSV с кешированием и прогрессом
+ * @param {string} csv - CSV строка
+ * @param {Object} options - Опции парсинга
+ * @param {Function} sendProgress - Функция отправки прогресса
+ * @returns {Array<Object>} JSON данные
+ */
+function parseCSVWithProgress(csv, options, sendProgress) {
+  const startTime = performance.now();
+  
+  // Проверка кеша
+  const cacheKey = generateCacheKey(csv, options);
+  if (cache.has(cacheKey)) {
+    const cached = cache.get(cacheKey);
+    stats.cacheHits++;
+    
+    // Отправка мгновенного прогресса для кешированных данных
+    if (sendProgress) {
+      sendProgress({
+        processed: cached.data.length,
+        total: cached.data.length,
+        percentage: 100,
+        fromCache: true
+      });
+    }
+    
+    return cached.data;
+  }
+  
+  stats.cacheMisses++;
+  
+  // Разделение на chunks для прогресса
+  const CHUNK_SIZE = 10000; // строк в chunk
+  const lines = csv.split('\n');
+  const totalLines = lines.length;
+  
+  let result = [];
+  let processedLines = 0;
+  
+  // Обработка по chunks
+  for (let i = 0; i < lines.length; i += CHUNK_SIZE) {
+    const chunk = lines.slice(i, i + CHUNK_SIZE).join('\n');
+    const chunkResult = csvToJson(chunk, options);
+    result = result.concat(chunkResult);
+    
+    processedLines = Math.min(i + CHUNK_SIZE, totalLines);
+    
+    // Отправка прогресса
+    if (sendProgress) {
+      const percentage = (processedLines / totalLines) * 100;
+      const elapsed = (performance.now() - startTime) / 1000;
+      const speed = processedLines / elapsed;
+      
+      sendProgress({
+        processed: processedLines,
+        total: totalLines,
+        percentage: percentage,
+        speed: speed,
+        elapsed: elapsed
+      });
+    }
+    
+    // Даем возможность обработать другие задачи
+    if (i % (CHUNK_SIZE * 10) === 0) {
+      // Небольшая пауза для неблокирующей обработки
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1);
+    }
+  }
+  
+  // Сохранение в кеш
+  cache.set(cacheKey, {
+    data: result,
+    timestamp: Date.now(),
+    size: csv.length
+  });
+  
+  // Очистка кеша если нужно
+  cleanupCache();
+  
+  // Обновление статистики
+  const processingTime = performance.now() - startTime;
+  stats.tasksProcessed++;
+  stats.totalProcessingTime += processingTime;
+  stats.averageProcessingTime = stats.totalProcessingTime / stats.tasksProcessed;
+  
+  return result;
+}
+
+/**
+ * Конвертация JSON в CSV
+ * @param {Array<Object>} jsonData - JSON данные
+ * @param {Object} options - Опции конвертации
+ * @returns {string} CSV строка
+ */
+function convertJSONToCSV(jsonData, options) {
+  return jsonToCsv(jsonData, options);
+}
+
+/**
+ * Валидация CSV строки
+ * @param {string} csv - CSV строка
+ * @param {Object} options - Опции валидации
+ * @returns {Object} Результат валидации
+ */
+function validateCSV(csv, options) {
+  const startTime = performance.now();
+  
+  try {
+    // Быстрый парсинг для валидации
+    const sampleSize = Math.min(1000, csv.split('\n').length);
+    const sample = csv.split('\n').slice(0, sampleSize).join('\n');
+    
+    const result = csvToJson(sample, options);
+    
+    const processingTime = performance.now() - startTime;
+    
+    return {
+      valid: true,
+      sampleSize: result.length,
+      estimatedTotalRows: csv.split('\n').length,
+      processingTime: processingTime,
+      estimatedFullProcessingTime: (processingTime / sampleSize) * csv.split('\n').length
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error.message,
+      processingTime: performance.now() - startTime
+    };
+  }
+}
+
+/**
+ * Получение статистики worker
+ * @returns {Object} Статистика
+ */
+function getStats() {
+  return {
+    ...stats,
+    cacheSize: cache.size,
+    cacheKeys: Array.from(cache.keys())
+  };
+}
+
+/**
+ * Очистка кеша worker
+ */
+function clearCache() {
+  cache.clear();
+  stats.cacheHits = 0;
+  stats.cacheMisses = 0;
+}
+
+function decodeCsvInput(input) {
+  if (typeof input === 'string') {
+    return input;
+  }
+  if (input instanceof ArrayBuffer) {
+    return textDecoder.decode(new Uint8Array(input));
+  }
+  if (ArrayBuffer.isView(input)) {
+    return textDecoder.decode(input);
+  }
+  throw new Error('Invalid CSV input type');
+}
+
+// Обработчик сообщений от основного потока
+self.onmessage = function (event) {
+  const { data } = event;
+  
+  switch (data.type) {
+  case 'EXECUTE':
+    handleExecute(data);
+    break;
+      
+  case 'GET_STATS':
+    self.postMessage({
+      type: 'STATS',
+      taskId: data.taskId,
+      data: getStats()
+    });
+    break;
+      
+  case 'CLEAR_CACHE':
+    clearCache();
+    self.postMessage({
+      type: 'CACHE_CLEARED',
+      taskId: data.taskId
+    });
+    break;
+      
+  default:
+    self.postMessage({
+      type: 'ERROR',
+      taskId: data.taskId,
+      message: `Unknown command: ${data.type}`
+    });
+  }
+};
+
+/**
+ * Обработка команды EXECUTE
+ * @param {Object} commandData - Данные команды
+ */
+function handleExecute(commandData) {
+  const { taskId, method, args = [], options = {} } = commandData;
+  
+  try {
+    switch (method) {
+    case 'parseCSV': {
+      const [csvInput, parseOptions] = args;
+      const csv = decodeCsvInput(csvInput);
+        
+      // Функция отправки прогресса
+      const sendProgress = (progress) => {
+        self.postMessage({
+          type: 'PROGRESS',
+          taskId,
+          ...progress
+        });
+      };
+        
+      const result = parseCSVWithProgress(csv, { ...options, ...parseOptions }, sendProgress);
+        
+      self.postMessage({
+        type: 'RESULT',
+        taskId,
+        data: result
+      });
+      break;
+    }
+        
+    case 'jsonToCSV': {
+      const [jsonData, csvOptions] = args;
+      const result = convertJSONToCSV(jsonData, { ...options, ...csvOptions });
+        
+      self.postMessage({
+        type: 'RESULT',
+        taskId,
+        data: result
+      });
+      break;
+    }
+        
+    case 'validateCSV': {
+      const [csv, validateOptions] = args;
+      const result = validateCSV(csv, { ...options, ...validateOptions });
+        
+      self.postMessage({
+        type: 'RESULT',
+        taskId,
+        data: result
+      });
+      break;
+    }
+        
+    case 'autoDetectDelimiter': {
+      const [csv] = args;
+      // Простая реализация автоопределения
+      const delimiters = [';', ',', '\t', '|'];
+      let bestDelimiter = ';';
+      let maxCount = 0;
+        
+      const firstLine = csv.split('\n')[0] || '';
+        
+      for (const delim of delimiters) {
+        const count = (firstLine.match(new RegExp(`[${delim}]`, 'g')) || []).length;
+        if (count > maxCount) {
+          maxCount = count;
+          bestDelimiter = delim;
+        }
+      }
+        
+      self.postMessage({
+        type: 'RESULT',
+        taskId,
+        data: bestDelimiter
+      });
+      break;
+    }
+        
+    default:
+      throw new Error(`Unknown method: ${method}`);
+    }
+  } catch (error) {
+    self.postMessage({
+      type: 'ERROR',
+      taskId,
+      message: error.message,
+      stack: error.stack,
+      code: error.code,
+      details: error.details
+    });
+  }
+}
+
+// Инициализация worker
+self.postMessage({ type: 'READY' });
+
+// Экспорт для тестирования
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    parseCSVWithProgress,
+    convertJSONToCSV,
+    validateCSV,
+    getStats,
+    clearCache
+  };
+}