jtcsv 2.2.8 → 3.1.0

package/src/browser/streams.js

@@ -1,393 +0,0 @@
-import {
-  ValidationError,
-  ConfigurationError,
-  LimitError
-} from './errors-browser.js';
-import { csvToJsonIterator } from './csv-to-json-browser.js';
-
-const DEFAULT_MAX_CHUNK_SIZE = 64 * 1024;
-
-function isReadableStream(value) {
-  return value && typeof value.getReader === 'function';
-}
-
-function isAsyncIterable(value) {
-  return value && typeof value[Symbol.asyncIterator] === 'function';
-}
-
-function isIterable(value) {
-  return value && typeof value[Symbol.iterator] === 'function';
-}
-
-function createReadableStreamFromIterator(iterator) {
-  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, options) {
-  if (options && options.inputFormat) {
-    return options.inputFormat;
-  }
-
-  if (typeof input === 'string') {
-    const trimmed = input.trim();
-    if (trimmed.startsWith('[')) {
-      return 'json-array';
-    }
-    if (trimmed.includes('\n')) {
-      return 'ndjson';
-    }
-    return 'json-array';
-  }
-
-  if (input instanceof Blob || isReadableStream(input)) {
-    return 'ndjson';
-  }
-
-  return 'json-array';
-}
-
-async function* parseNdjsonText(text) {
-  const lines = text.split(/\r?\n/);
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    yield JSON.parse(trimmed);
-  }
-}
-
-async function* parseNdjsonStream(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder('utf-8');
-  let buffer = '';
-
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) {
-      break;
-    }
-
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split(/\r?\n/);
-    buffer = lines.pop() || '';
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) {
-        continue;
-      }
-      yield JSON.parse(trimmed);
-    }
-  }
-
-  if (buffer.trim()) {
-    yield JSON.parse(buffer.trim());
-  }
-}
-
-async function* normalizeJsonInput(input, options = {}) {
-  const format = detectInputFormat(input, options);
-
-  if (Array.isArray(input)) {
-    for (const item of input) {
-      yield item;
-    }
-    return;
-  }
-
-  if (isAsyncIterable(input)) {
-    for await (const item of input) {
-      yield item;
-    }
-    return;
-  }
-
-  if (isIterable(input)) {
-    for (const item of input) {
-      yield item;
-    }
-    return;
-  }
-
-  if (typeof input === 'string') {
-    if (format === 'ndjson') {
-      yield* parseNdjsonText(input);
-      return;
-    }
-
-    const parsed = JSON.parse(input);
-    if (Array.isArray(parsed)) {
-      for (const item of parsed) {
-        yield item;
-      }
-      return;
-    }
-    yield parsed;
-    return;
-  }
-
-  if (input instanceof Blob) {
-    if (format === 'ndjson') {
-      yield* parseNdjsonStream(input.stream());
-      return;
-    }
-
-    const text = await input.text();
-    const parsed = JSON.parse(text);
-    if (Array.isArray(parsed)) {
-      for (const item of parsed) {
-        yield item;
-      }
-      return;
-    }
-    yield parsed;
-    return;
-  }
-
-  if (isReadableStream(input)) {
-    if (format !== 'ndjson') {
-      throw new ValidationError('ReadableStream input requires inputFormat="ndjson"');
-    }
-    yield* parseNdjsonStream(input);
-    return;
-  }
-
-  throw new ValidationError('Input must be an array, iterable, string, Blob, or ReadableStream');
-}
-
-function validateStreamOptions(options) {
-  if (options && typeof options !== 'object') {
-    throw new ConfigurationError('Options must be an object');
-  }
-
-  if (options?.delimiter && typeof options.delimiter !== 'string') {
-    throw new ConfigurationError('Delimiter must be a string');
-  }
-
-  if (options?.delimiter && options.delimiter.length !== 1) {
-    throw new ConfigurationError('Delimiter must be a single character');
-  }
-
-  if (options?.renameMap && typeof options.renameMap !== 'object') {
-    throw new ConfigurationError('renameMap must be an object');
-  }
-
-  if (options?.maxRecords !== undefined) {
-    if (typeof options.maxRecords !== 'number' || options.maxRecords <= 0) {
-      throw new ConfigurationError('maxRecords must be a positive number');
-    }
-  }
-}
-
-function escapeCsvValue(value, options) {
-  const {
-    delimiter,
-    preventCsvInjection = true,
-    rfc4180Compliant = true
-  } = options;
-
-  if (value === null || value === undefined || value === '') {
-    return '';
-  }
-
-  const stringValue = String(value);
-  let escapedValue = stringValue;
-  if (preventCsvInjection && /^[=+\-@]/.test(stringValue)) {
-    escapedValue = "'" + stringValue;
-  }
-
-  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) {
-    return `"${escapedValue.replace(/"/g, '""')}"`;
-  }
-
-  return escapedValue;
-}
-
-function buildHeaderState(keys, options) {
-  const renameMap = options.renameMap || {};
-  const template = options.template || {};
-  const originalKeys = Array.isArray(options.headers) ? options.headers : keys;
-  const headers = originalKeys.map((key) => renameMap[key] || key);
-
-  const reverseRenameMap = {};
-  originalKeys.forEach((key, index) => {
-    reverseRenameMap[headers[index]] = key;
-  });
-
-  let finalHeaders = headers;
-  if (Object.keys(template).length > 0) {
-    const templateHeaders = Object.keys(template).map(key => renameMap[key] || key);
-    const extraHeaders = headers.filter(h => !templateHeaders.includes(h));
-    finalHeaders = [...templateHeaders, ...extraHeaders];
-  }
-
-  return {
-    headers: finalHeaders,
-    reverseRenameMap
-  };
-}
-
-async function* jsonToCsvChunkIterator(input, options = {}) {
-  validateStreamOptions(options);
-
-  const opts = options && typeof options === 'object' ? options : {};
-  const {
-    delimiter = ';',
-    includeHeaders = true,
-    maxRecords,
-    maxChunkSize = DEFAULT_MAX_CHUNK_SIZE,
-    headerMode
-  } = opts;
-
-  let headerState = null;
-  let buffer = '';
-  let recordCount = 0;
-  const lineEnding = opts.rfc4180Compliant === false ? '\n' : '\r\n';
-
-  if (Array.isArray(input) && !opts.headers && (!headerMode || headerMode === 'all')) {
-    const allKeys = new Set();
-    for (const item of input) {
-      if (!item || typeof item !== 'object') {
-        continue;
-      }
-      Object.keys(item).forEach((key) => allKeys.add(key));
-    }
-    headerState = buildHeaderState(Array.from(allKeys), opts);
-    if (includeHeaders && headerState.headers.length > 0) {
-      buffer += headerState.headers.join(delimiter) + lineEnding;
-    }
-  } else if (Array.isArray(opts.headers)) {
-    headerState = buildHeaderState(opts.headers, opts);
-    if (includeHeaders && headerState.headers.length > 0) {
-      buffer += headerState.headers.join(delimiter) + lineEnding;
-    }
-  }
-
-  for await (const item of normalizeJsonInput(input, opts)) {
-    if (!item || typeof item !== 'object') {
-      continue;
-    }
-
-    if (!headerState) {
-      headerState = buildHeaderState(Object.keys(item), opts);
-      if (includeHeaders && headerState.headers.length > 0) {
-        buffer += headerState.headers.join(delimiter) + lineEnding;
-      }
-    }
-
-    recordCount += 1;
-    if (maxRecords && recordCount > maxRecords) {
-      throw new LimitError(
-        `Data size exceeds maximum limit of ${maxRecords} records`,
-        maxRecords,
-        recordCount
-      );
-    }
-
-    const row = headerState.headers.map((header) => {
-      const originalKey = headerState.reverseRenameMap[header] || header;
-      return escapeCsvValue(item[originalKey], {
-        delimiter,
-        preventCsvInjection: opts.preventCsvInjection !== false,
-        rfc4180Compliant: opts.rfc4180Compliant !== false
-      });
-    }).join(delimiter);
-
-    buffer += row + lineEnding;
-
-    if (buffer.length >= maxChunkSize) {
-      yield buffer;
-      buffer = '';
-    }
-  }
-
-  if (buffer.length > 0) {
-    yield buffer;
-  }
-}
-
-async function* jsonToNdjsonChunkIterator(input, options = {}) {
-  validateStreamOptions(options);
-  for await (const item of normalizeJsonInput(input, options)) {
-    if (item === undefined) {
-      continue;
-    }
-    yield JSON.stringify(item) + '\n';
-  }
-}
-
-async function* csvToJsonChunkIterator(input, options = {}) {
-  const outputFormat = options.outputFormat || 'ndjson';
-  const asArray = outputFormat === 'json-array' || outputFormat === 'array' || outputFormat === 'json';
-  let first = true;
-
-  if (asArray) {
-    yield '[';
-  }
-
-  for await (const row of csvToJsonIterator(input, options)) {
-    const payload = JSON.stringify(row);
-    if (asArray) {
-      yield (first ? '' : ',') + payload;
-    } else {
-      yield payload + '\n';
-    }
-    first = false;
-  }
-
-  if (asArray) {
-    yield ']';
-  }
-}
-
-export function jsonToCsvStream(input, options = {}) {
-  const iterator = jsonToCsvChunkIterator(input, options);
-  return createReadableStreamFromIterator(iterator);
-}
-
-export function jsonToNdjsonStream(input, options = {}) {
-  const iterator = jsonToNdjsonChunkIterator(input, options);
-  return createReadableStreamFromIterator(iterator);
-}
-
-export function csvToJsonStream(input, options = {}) {
-  const iterator = csvToJsonChunkIterator(input, options);
-  return createReadableStreamFromIterator(iterator);
-}
-
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = {
-    jsonToCsvStream,
-    jsonToNdjsonStream,
-    csvToJsonStream
-  };
-}

package/src/core/delimiter-cache.js

@@ -1,186 +0,0 @@
-/**
- * Кэширование результатов авто-детектирования разделителя
- * Использует WeakMap и LRU кэш для оптимизации производительности
- * 
- * @version 1.0.0
- * @date 2026-01-23
- */
-
-class DelimiterCache {
-  constructor(maxSize = 100) {
-    this.weakMap = new WeakMap();
-    this.lruCache = new Map();
-    this.maxSize = maxSize;
-    this.stats = {
-      hits: 0,
-      misses: 0,
-      evictions: 0,
-      size: 0
-    };
-  }
-
-  /**
-   * Генерирует ключ кэша на основе строки и кандидатов
-   * @private
-   */
-  _generateKey(csv, candidates) {
-    // Используем хэш первых 1000 символов для производительности
-    const sample = csv.substring(0, Math.min(1000, csv.length));
-    const candidatesKey = candidates.join(',');
-    return `${this._hashString(sample)}:${candidatesKey}`;
-  }
-
-  /**
-   * Простая хэш-функция для строк
-   * @private
-   */
-  _hashString(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-      const char = str.charCodeAt(i);
-      hash = ((hash << 5) - hash) + char;
-      hash = hash & hash; // Convert to 32bit integer
-    }
-    return hash.toString(36);
-  }
-
-  /**
-   * Получает значение из кэша
-   * @param {string} csv - CSV строка
-   * @param {Array} candidates - Кандидаты разделителей
-   * @returns {string|null} Кэшированный разделитель или null
-   */
-  get(csv, candidates) {
-    const key = this._generateKey(csv, candidates);
-    
-    // Проверяем LRU кэш
-    if (this.lruCache.has(key)) {
-      // Обновляем позицию в LRU
-      const value = this.lruCache.get(key);
-      this.lruCache.delete(key);
-      this.lruCache.set(key, value);
-      this.stats.hits++;
-      return value;
-    }
-    
-    this.stats.misses++;
-    return null;
-  }
-
-  /**
-   * Сохраняет значение в кэш
-   * @param {string} csv - CSV строка
-   * @param {Array} candidates - Кандидаты разделителей
-   * @param {string} delimiter - Найденный разделитель
-   */
-  set(csv, candidates, delimiter) {
-    const key = this._generateKey(csv, candidates);
-    
-    // Проверяем необходимость вытеснения из LRU кэша
-    if (this.lruCache.size >= this.maxSize) {
-      // Удаляем самый старый элемент (первый в Map)
-      const firstKey = this.lruCache.keys().next().value;
-      this.lruCache.delete(firstKey);
-      this.stats.evictions++;
-    }
-    
-    // Сохраняем в LRU кэш
-    this.lruCache.set(key, delimiter);
-    this.stats.size = this.lruCache.size;
-    
-    // Также сохраняем в WeakMap если csv является объектом
-    if (typeof csv === 'object' && csv !== null) {
-      this.weakMap.set(csv, { candidates, delimiter });
-    }
-  }
-
-  /**
-   * Очищает кэш
-   */
-  clear() {
-    this.lruCache.clear();
-    this.weakMap = new WeakMap();
-    this.stats = {
-      hits: 0,
-      misses: 0,
-      evictions: 0,
-      size: 0
-    };
-  }
-
-  /**
-   * Возвращает статистику кэша
-   * @returns {Object} Статистика
-   */
-  getStats() {
-    const total = this.stats.hits + this.stats.misses;
-    return {
-      ...this.stats,
-      hitRate: total > 0 ? (this.stats.hits / total) * 100 : 0,
-      totalRequests: total
-    };
-  }
-
-  /**
-   * Оптимизированная версия autoDetectDelimiter с кэшированием
-   * @param {string} csv - CSV строка
-   * @param {Array} candidates - Кандидаты разделителей
-   * @param {DelimiterCache} cache - Экземпляр кэша (опционально)
-   * @returns {string} Найденный разделитель
-   */
-  static autoDetectDelimiter(csv, candidates = [';', ',', '\t', '|'], cache = null) {
-    if (!csv || typeof csv !== 'string') {
-      return ';';
-    }
-
-    // Проверяем кэш если он предоставлен
-    if (cache) {
-      const cached = cache.get(csv, candidates);
-      if (cached !== null) {
-        return cached;
-      }
-    }
-
-    const lines = csv.split('\n').filter(line => line.trim().length > 0);
-    
-    if (lines.length === 0) {
-      return ';';
-    }
-
-    // Используем первую непустую строку для детектирования
-    const firstLine = lines[0];
-    
-    const counts = {};
-    candidates.forEach(delim => {
-      const escapedDelim = delim.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      const regex = new RegExp(escapedDelim, 'g');
-      const matches = firstLine.match(regex);
-      counts[delim] = matches ? matches.length : 0;
-    });
-
-    // Находим разделитель с максимальным количеством
-    let maxCount = -1;
-    let detectedDelimiter = ';';
-    
-    for (const [delim, count] of Object.entries(counts)) {
-      if (count > maxCount) {
-        maxCount = count;
-        detectedDelimiter = delim;
-      }
-    }
-
-    // Если разделитель не найден или есть ничья, возвращаем стандартный
-    if (maxCount === 0) {
-      detectedDelimiter = ';';
-    }
-
-    // Сохраняем в кэш если он предоставлен
-    if (cache) {
-      cache.set(csv, candidates, detectedDelimiter);
-    }
-
-    return detectedDelimiter;
-  }
-}
-
-module.exports = DelimiterCache;