jtcsv 2.1.0 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jtcsv",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "Complete JSON↔CSV and CSV↔JSON converter for Node.js and Browser with streaming, security, Web Workers, TypeScript support, and Plugin System - Zero dependencies",
   "main": "index.js",
   "browser": "dist/jtcsv.umd.js",
@@ -9,7 +9,7 @@
   "bin": {
     "jtcsv": "bin/jtcsv.js"
   },
-    "exports": {
+  "exports": {
     ".": {
       "require": "./index.js",
       "import": "./dist/jtcsv.esm.js",
@@ -56,7 +56,7 @@
     "test:plugins": "jest __tests__/plugin-system.test.js",
     "test:fastpath": "jest __tests__/fast-path-engine.test.js",
     "test:ndjson": "jest __tests__/ndjson-parser.test.js",
-        "test:performance": "jest __tests__/*.test.js --testNamePattern=\"Производительность|производительность\"",
+    "test:performance": "jest __tests__/*.test.js --testNamePattern=\"Производительность|производительность\"",
     "test:express": "cd plugins/express-middleware && npm test",
     "test:fastify": "cd plugins/fastify-plugin && npm test",
     "test:nextjs": "cd plugins/nextjs-api && npm test",
@@ -118,7 +118,7 @@
     "gui",
     "tool",
     "utility",
-        "plugin-system",
+    "plugin-system",
     "ndjson",
     "fast-path",
     "optimization",
@@ -155,7 +155,7 @@
     "stream-csv-to-json.js",
     "json-save.js",
     "index.d.ts",
-        "bin/",
+    "bin/",
     "cli-tui.js",
     "dist/",
     "src/",
@@ -169,33 +169,45 @@
     "@rollup/plugin-commonjs": "^25.0.0",
     "@rollup/plugin-node-resolve": "^15.0.0",
     "@rollup/plugin-terser": "^0.4.0",
+    "@size-limit/preset-small-lib": "12.0.0",
     "eslint": "8.57.1",
     "jest": "^29.0.0",
     "rollup": "^4.0.0",
-    "size-limit": "^8.0.0"
+    "size-limit": "12.0.0"
   },
   "optionalDependencies": {
     "blessed": "^0.1.81",
-    "blessed-contrib": "^4.11.0",
+    "blessed-contrib": "4.11.0",
     "exceljs": "^4.4.0"
   },
+  "overrides": {
+    "xml2js": "0.6.2"
+  },
   "type": "commonjs",
   "size-limit": [
     {
       "path": "dist/jtcsv.umd.js",
-      "limit": "35 KB"
+      "limit": "60 KB",
+      "ignore": [
+        "url"
+      ]
     },
     {
       "path": "dist/jtcsv.esm.js",
-      "limit": "30 KB"
+      "limit": "55 KB",
+      "ignore": [
+        "url"
+      ]
     }
   ],
   "browserslist": [
     "defaults",
     "not IE 11",
     "maintained node versions"
-  ]
+  ],
+  "dependencies": {
+    "csv-parser": "3.2.0",
+    "json2csv": "6.0.0-alpha.2",
+    "papaparse": "5.5.3"
+  }
 }
-
-
-

package/src/core/delimiter-cache.js

@@ -0,0 +1,186 @@
+/**
+ * Кэширование результатов авто-детектирования разделителя
+ * Использует 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;

package/src/core/transform-hooks.js

@@ -0,0 +1,350 @@
+/**
+ * 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
+};