jtcsv 3.0.0 → 3.1.0

package/src/core/transform-hooks.js

@@ -1,350 +0,0 @@
-/**
- * Transform Hooks System
- * Система хуков для трансформации данных перед/после конвертации
- * 
- * @version 1.0.0
- * @date 2026-01-23
- */
-
-const { ValidationError } = require('../../errors');
-
-class TransformHooks {
-  constructor() {
-    this.hooks = {
-      beforeConvert: [],
-      afterConvert: [],
-      perRow: []
-    };
-  }
-
-  /**
-   * Регистрирует хук beforeConvert
-   * @param {Function} hook - Функция хука
-   * @returns {TransformHooks} this для цепочки вызовов
-   */
-  beforeConvert(hook) {
-    if (typeof hook !== 'function') {
-      throw new ValidationError('beforeConvert hook must be a function');
-    }
-    this.hooks.beforeConvert.push(hook);
-    return this;
-  }
-
-  /**
-   * Регистрирует хук afterConvert
-   * @param {Function} hook - Функция хука
-   * @returns {TransformHooks} this для цепочки вызовов
-   */
-  afterConvert(hook) {
-    if (typeof hook !== 'function') {
-      throw new ValidationError('afterConvert hook must be a function');
-    }
-    this.hooks.afterConvert.push(hook);
-    return this;
-  }
-
-  /**
-   * Регистрирует per-row хук
-   * @param {Function} hook - Функция хука
-   * @returns {TransformHooks} this для цепочки вызовов
-   */
-  perRow(hook) {
-    if (typeof hook !== 'function') {
-      throw new ValidationError('perRow hook must be a function');
-    }
-    this.hooks.perRow.push(hook);
-    return this;
-  }
-
-  /**
-   * Применяет beforeConvert хуки
-   * @param {any} data - Входные данные
-   * @param {Object} context - Контекст выполнения
-   * @returns {any} Трансформированные данные
-   */
-  applyBeforeConvert(data, context = {}) {
-    let result = data;
-    for (const hook of this.hooks.beforeConvert) {
-      result = hook(result, context);
-    }
-    return result;
-  }
-
-  /**
-   * Применяет afterConvert хуки
-   * @param {any} data - Выходные данные
-   * @param {Object} context - Контекст выполнения
-   * @returns {any} Трансформированные данные
-   */
-  applyAfterConvert(data, context = {}) {
-    let result = data;
-    for (const hook of this.hooks.afterConvert) {
-      result = hook(result, context);
-    }
-    return result;
-  }
-
-  /**
-   * Применяет per-row хуки
-   * @param {any} row - Строка данных
-   * @param {number} index - Индекс строки
-   * @param {Object} context - Контекст выполнения
-   * @returns {any} Трансформированная строка
-   */
-  applyPerRow(row, index, context = {}) {
-    let result = row;
-    for (const hook of this.hooks.perRow) {
-      result = hook(result, index, context);
-    }
-    return result;
-  }
-
-  /**
-   * Применяет все хуки к массиву данных
-   * @param {Array} data - Массив данных
-   * @param {Object} context - Контекст выполнения
-   * @returns {Array} Трансформированный массив
-   */
-  applyAll(data, context = {}) {
-    if (!Array.isArray(data)) {
-      throw new ValidationError('Data must be an array for applyAll');
-    }
-
-    // Применяем beforeConvert хуки
-    let processedData = this.applyBeforeConvert(data, context);
-
-    // Применяем per-row хуки к каждой строке
-    if (this.hooks.perRow.length > 0) {
-      processedData = processedData.map((row, index) => 
-        this.applyPerRow(row, index, context)
-      );
-    }
-
-    // Применяем afterConvert хуки
-    return this.applyAfterConvert(processedData, context);
-  }
-
-  /**
-   * Создает копию системы хуков
-   * @returns {TransformHooks} Новая копия
-   */
-  clone() {
-    const cloned = new TransformHooks();
-    cloned.hooks = {
-      beforeConvert: [...this.hooks.beforeConvert],
-      afterConvert: [...this.hooks.afterConvert],
-      perRow: [...this.hooks.perRow]
-    };
-    return cloned;
-  }
-
-  /**
-   * Очищает все хуки
-   */
-  clear() {
-    this.hooks = {
-      beforeConvert: [],
-      afterConvert: [],
-      perRow: []
-    };
-  }
-
-  /**
-   * Возвращает статистику по хукам
-   * @returns {Object} Статистика
-   */
-  getStats() {
-    return {
-      beforeConvert: this.hooks.beforeConvert.length,
-      afterConvert: this.hooks.afterConvert.length,
-      perRow: this.hooks.perRow.length,
-      total: this.hooks.beforeConvert.length + 
-             this.hooks.afterConvert.length + 
-             this.hooks.perRow.length
-    };
-  }
-}
-
-/**
- * Предопределенные хуки
- */
-const predefinedHooks = {
-  /**
-   * Хук для фильтрации данных
-   * @param {Function} predicate - Функция-предикат
-   * @returns {Function} Хук фильтрации
-   */
-  filter(predicate) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.filter(predicate);
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для маппинга данных
-   * @param {Function} mapper - Функция-маппер
-   * @returns {Function} Хук маппинга
-   */
-  map(mapper) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.map(mapper);
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для сортировки данных
-   * @param {Function} compareFn - Функция сравнения
-   * @returns {Function} Хук сортировки
-   */
-  sort(compareFn) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return [...data].sort(compareFn);
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для ограничения количества записей
-   * @param {number} limit - Максимальное количество записей
-   * @returns {Function} Хук ограничения
-   */
-  limit(limit) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.slice(0, limit);
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для добавления метаданных
-   * @param {Object} metadata - Метаданные для добавления
-   * @returns {Function} Хук добавления метаданных
-   */
-  addMetadata(metadata) {
-    return (data, context) => {
-      if (Array.isArray(data)) {
-        return data.map(item => ({
-          ...item,
-          _metadata: {
-            ...metadata,
-            timestamp: new Date().toISOString(),
-            context
-          }
-        }));
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для преобразования ключей
-   * @param {Function} keyTransformer - Функция преобразования ключей
-   * @returns {Function} Хук преобразования ключей
-   */
-  transformKeys(keyTransformer) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.map(item => {
-          const transformed = {};
-          for (const [key, value] of Object.entries(item)) {
-            transformed[keyTransformer(key)] = value;
-          }
-          return transformed;
-        });
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для преобразования значений
-   * @param {Function} valueTransformer - Функция преобразования значений
-   * @returns {Function} Хук преобразования значений
-   */
-  transformValues(valueTransformer) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.map(item => {
-          const transformed = {};
-          for (const [key, value] of Object.entries(item)) {
-            transformed[key] = valueTransformer(value, key);
-          }
-          return transformed;
-        });
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для валидации данных
-   * @param {Function} validator - Функция валидации
-   * @param {Function} onError - Обработчик ошибки
-   * @returns {Function} Хук валидации
-   */
-  validate(validator, onError = console.error) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        const validData = [];
-        const errors = [];
-
-        data.forEach((item, index) => {
-          try {
-            const isValid = validator(item, index);
-            if (isValid) {
-              validData.push(item);
-            } else {
-              errors.push({ index, item, reason: 'Validation failed' });
-            }
-          } catch (error) {
-            errors.push({ index, item, error: error.message });
-          }
-        });
-
-        if (errors.length > 0) {
-          onError('Validation errors:', errors);
-        }
-
-        return validData;
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для дедупликации данных
-   * @param {Function} keySelector - Функция выбора ключа
-   * @returns {Function} Хук дедупликации
-   */
-  deduplicate(keySelector = JSON.stringify) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        const seen = new Set();
-        return data.filter(item => {
-          const key = keySelector(item);
-          if (seen.has(key)) {
-            return false;
-          }
-          seen.add(key);
-          return true;
-        });
-      }
-      return data;
-    };
-  }
-};
-
-module.exports = {
-  TransformHooks,
-  predefinedHooks
-};

package/src/engines/fast-path-engine-new.js

@@ -1,338 +0,0 @@
-/**
- * Fast-Path Engine для оптимизации CSV парсинга
- * Автоматически выбирает оптимальный парсер на основе структуры CSV
- * 
- * @version 1.0.0
- * @date 2026-01-22
- */
-
-class FastPathEngine {
-  constructor() {
-    this.compilers = new Map();
-    this.stats = {
-      simpleParserCount: 0,
-      quoteAwareParserCount: 0,
-      standardParserCount: 0,
-      cacheHits: 0,
-      cacheMisses: 0
-    };
-  }
-
-  /**
-   * Анализирует структуру CSV и определяет оптимальный парсер
-   */
-  analyzeStructure(sample, options = {}) {
-    const delimiter = options.delimiter || this._detectDelimiter(sample);
-    const lines = sample.split('\n').slice(0, 10);
-    
-    let hasQuotes = false;
-    let hasNewlinesInFields = false;
-    let hasEscapedQuotes = false;
-    let maxFields = 0;
-    let totalFields = 0;
-
-    for (const line of lines) {
-      if (line.includes('"')) {
-        hasQuotes = true;
-        if (line.includes('""')) {
-          hasEscapedQuotes = true;
-        }
-      }
-      
-      const quoteCount = (line.match(/"/g) || []).length;
-      if (quoteCount % 2 !== 0) {
-        hasNewlinesInFields = true;
-      }
-
-      const fieldCount = line.split(delimiter).length;
-      totalFields += fieldCount;
-      if (fieldCount > maxFields) {
-        maxFields = fieldCount;
-      }
-    }
-
-    const avgFieldsPerLine = totalFields / lines.length;
-    const fieldConsistency = maxFields === avgFieldsPerLine;
-
-    return {
-      delimiter,
-      hasQuotes,
-      hasEscapedQuotes,
-      hasNewlinesInFields,
-      fieldConsistency,
-      avgFieldsPerLine,
-      maxFields,
-      recommendedEngine: this._selectEngine(hasQuotes, hasNewlinesInFields, fieldConsistency)
-    };
-  }
-
-  /**
-   * Автоматически определяет разделитель
-   */
-  _detectDelimiter(sample) {
-    const candidates = [',', ';', '\t', '|'];
-    const firstLine = sample.split('\n')[0];
-    
-    let bestDelimiter = ',';
-    let bestScore = 0;
-
-    for (const delimiter of candidates) {
-      const fields = firstLine.split(delimiter);
-      const score = fields.length;
-      
-      const avgLength = fields.reduce((sum, field) => sum + field.length, 0) / fields.length;
-      const variance = fields.reduce((sum, field) => sum + Math.pow(field.length - avgLength, 2), 0) / fields.length;
-      
-      const finalScore = score / (variance + 1);
-      
-      if (finalScore > bestScore) {
-        bestScore = finalScore;
-        bestDelimiter = delimiter;
-      }
-    }
-
-    return bestDelimiter;
-  }
-
-  /**
-   * Выбирает оптимальный движок парсинга
-   */
-  _selectEngine(hasQuotes, hasNewlinesInFields, fieldConsistency) {
-    if (!hasQuotes && !hasNewlinesInFields && fieldConsistency) {
-      return 'SIMPLE';
-    }
-    
-    if (hasQuotes && !hasNewlinesInFields) {
-      return 'QUOTE_AWARE';
-    }
-    
-    return 'STANDARD';
-  }
-
-  /**
-   * Компилирует специализированный парсер для конкретной структуры
-   */
-  compileParser(structure) {
-    const cacheKey = JSON.stringify(structure);
-    
-    if (this.compilers.has(cacheKey)) {
-      this.stats.cacheHits++;
-      return this.compilers.get(cacheKey);
-    }
-
-    this.stats.cacheMisses++;
-    let parser;
-
-    switch (structure.recommendedEngine) {
-    case 'SIMPLE':
-      parser = this._createSimpleParser(structure);
-      this.stats.simpleParserCount++;
-      break;
-    case 'QUOTE_AWARE':
-      parser = this._createQuoteAwareParser(structure);
-      this.stats.quoteAwareParserCount++;
-      break;
-    default:
-      parser = this._createStandardParser(structure);
-      this.stats.standardParserCount++;
-    }
-
-    this.compilers.set(cacheKey, parser);
-    return parser;
-  }
-
-  /**
-   * Regex-based парсер для простых CSV (без кавычек)
-   */
-  _createSimpleParser(structure) {
-    const { delimiter } = structure;
-    
-    return (csv) => {
-      const rows = [];
-      const lines = csv.split('\n');
-      
-      for (const line of lines) {
-        if (line.trim() === '') {
-          continue;
-        }
-        
-        const fields = line.split(delimiter).map(field => field.trim());
-        if (fields.length > 0 && fields.some(field => field !== '')) {
-          rows.push(fields);
-        }
-      }
-      
-      return rows;
-    };
-  }
-
-  /**
-   * State machine парсер для CSV с кавычками (RFC 4180)
-   */
-  _createQuoteAwareParser(structure) {
-    const { delimiter, hasEscapedQuotes } = structure;
-    
-    return (csv) => {
-      const rows = [];
-      let currentRow = [];
-      let currentField = '';
-      let insideQuotes = false;
-      let i = 0;
-
-      while (i < csv.length) {
-        const char = csv[i];
-        const nextChar = csv[i + 1];
-
-        if (char === '"') {
-          if (insideQuotes) {
-            if (nextChar === '"' && hasEscapedQuotes) {
-              currentField += '"';
-              i += 2;
-            } else {
-              insideQuotes = false;
-              i++;
-            }
-          } else {
-            insideQuotes = true;
-            i++;
-          }
-        } else if (char === delimiter && !insideQuotes) {
-          currentRow.push(currentField);
-          currentField = '';
-          i++;
-        } else if ((char === '\n' || (char === '\r' && nextChar === '\n')) && !insideQuotes) {
-          currentRow.push(currentField);
-          if (currentRow.length > 0 && currentRow.some(field => field !== '')) {
-            rows.push(currentRow);
-          }
-          currentRow = [];
-          currentField = '';
-          i += (char === '\r' && nextChar === '\n') ? 2 : 1;
-        } else {
-          currentField += char;
-          i++;
-        }
-      }
-
-      if (currentField !== '' || currentRow.length > 0) {
-        currentRow.push(currentField);
-        if (currentRow.length > 0 && currentRow.some(field => field !== '')) {
-          rows.push(currentRow);
-        }
-      }
-
-      return rows;
-    };
-  }
-
-  /**
-   * Стандартный парсер (fallback)
-   */
-  _createStandardParser(structure) {
-    const { delimiter } = structure;
-    
-    return (csv) => {
-      const rows = [];
-      const lines = csv.split('\n');
-      let insideQuotes = false;
-      let currentLine = '';
-      
-      for (const line of lines) {
-        const quoteCount = (line.match(/"/g) || []).length;
-        
-        if (insideQuotes) {
-          currentLine += '\n' + line;
-          if (quoteCount % 2 !== 0) {
-            insideQuotes = false;
-            rows.push(this._parseLineWithQuotes(currentLine, delimiter));
-            currentLine = '';
-          }
-        } else {
-          if (quoteCount % 2 !== 0) {
-            insideQuotes = true;
-            currentLine = line;
-          } else {
-            rows.push(this._parseLineWithQuotes(line, delimiter));
-          }
-        }
-      }
-      
-      return rows;
-    };
-  }
-
-  /**
-   * Парсит строку с учетом кавычек
-   */
-  _parseLineWithQuotes(line, delimiter) {
-    const fields = [];
-    let currentField = '';
-    let insideQuotes = false;
-    let i = 0;
-
-    while (i < line.length) {
-      const char = line[i];
-      const nextChar = line[i + 1];
-
-      if (char === '"') {
-        if (insideQuotes && nextChar === '"') {
-          currentField += '"';
-          i += 2;
-        } else {
-          insideQuotes = !insideQuotes;
-          i++;
-        }
-      } else if (char === delimiter && !insideQuotes) {
-        fields.push(currentField);
-        currentField = '';
-        i++;
-      } else {
-        currentField += char;
-        i++;
-      }
-    }
-
-    fields.push(currentField);
-    return fields;
-  }
-
-  /**
-   * Парсит CSV с использованием оптимального парсера
-   */
-  parse(csv, options = {}) {
-    const sampleSize = Math.min(1000, csv.length);
-    const sample = csv.substring(0, sampleSize);
-    
-    const structure = this.analyzeStructure(sample, options);
-    const parser = this.compileParser(structure);
-    
-    return parser(csv);
-  }
-
-  /**
-   * Возвращает статистику использования парсеров
-   */
-  getStats() {
-    return {
-      ...this.stats,
-      totalParsers: this.compilers.size,
-      hitRate: this.stats.cacheHits / (this.stats.cacheHits + this.stats.cacheMisses) || 0
-    };
-  }
-
-  /**
-   * Сбрасывает статистику и кеш
-   */
-  reset() {
-    this.compilers.clear();
-    this.stats = {
-      simpleParserCount: 0,
-      quoteAwareParserCount: 0,
-      standardParserCount: 0,
-      cacheHits: 0,
-      cacheMisses: 0
-    };
-  }
-}
-
-module.exports = FastPathEngine;