jtcsv 2.2.7 → 3.0.0

package/src/browser/core.js

@@ -0,0 +1,92 @@
+// Ядро jtcsv - только базовые функции JSON<->CSV
+// Минимальный размер, максимальная производительность
+
+import { jsonToCsv, preprocessData, deepUnwrap } from './json-to-csv-browser.js';
+import { csvToJson, csvToJsonIterator, autoDetectDelimiter } from './csv-to-json-browser.js';
+import {
+  downloadAsCsv,
+  parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream
+} from './browser-functions.js';
+import {
+  ValidationError,
+  SecurityError,
+  FileSystemError,
+  ParsingError,
+  LimitError,
+  ConfigurationError,
+  ERROR_CODES
+} from './errors-browser.js';
+
+// Основной экспорт ядра
+const jtcsvCore = {
+  // JSON to CSV функции
+  jsonToCsv,
+  preprocessData,
+  downloadAsCsv,
+  deepUnwrap,
+  
+  // CSV to JSON функции
+  csvToJson,
+  csvToJsonIterator,
+  parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream,
+  autoDetectDelimiter,
+  
+  // Error classes
+  ValidationError,
+  SecurityError,
+  FileSystemError,
+  ParsingError,
+  LimitError,
+  ConfigurationError,
+  ERROR_CODES,
+  
+  // Удобные алиасы
+  parse: csvToJson,
+  unparse: jsonToCsv,
+  
+  // Версия
+  version: '3.0.0-core'
+};
+
+// Экспорт для разных сред
+if (typeof module !== 'undefined' && module.exports) {
+  // Node.js CommonJS
+  module.exports = jtcsvCore;
+} else if (typeof define === 'function' && define.amd) {
+  // AMD
+  define([], () => jtcsvCore);
+} else if (typeof window !== 'undefined') {
+  // Браузер (глобальная переменная)
+  window.jtcsv = jtcsvCore;
+}
+
+export default jtcsvCore;
+export {
+  jsonToCsv,
+  preprocessData,
+  downloadAsCsv,
+  deepUnwrap,
+  csvToJson,
+  csvToJsonIterator,
+  parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream,
+  autoDetectDelimiter,
+  ValidationError,
+  SecurityError,
+  FileSystemError,
+  ParsingError,
+  LimitError,
+  ConfigurationError,
+  ERROR_CODES
+};

package/src/browser/core.ts

@@ -0,0 +1,152 @@
+// Ядро jtcsv - только базовые функции JSON<->CSV
+// Минимальный размер, максимальная производительность
+
+import * as jsonToCsvBrowser from './json-to-csv-browser';
+import * as csvToJsonBrowser from './csv-to-json-browser';
+import {
+  downloadAsCsv,
+  parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream
+} from './browser-functions';
+import {
+  ValidationError,
+  SecurityError,
+  FileSystemError,
+  ParsingError,
+  LimitError,
+  ConfigurationError,
+  ERROR_CODES
+} from './errors-browser';
+
+import type { JsonToCsvOptions, CsvToJsonOptions } from '../types';
+
+const { jsonToCsv, preprocessData, deepUnwrap } = jsonToCsvBrowser as any;
+const { csvToJson, csvToJsonIterator, autoDetectDelimiter } = csvToJsonBrowser as any;
+
+/**
+ * Асинхронная версия jsonToCsv
+ */
+async function jsonToCsvAsync(data: any, options: JsonToCsvOptions = {}): Promise<string> {
+  return jsonToCsv(data, options);
+}
+
+/**
+ * Асинхронная версия csvToJson
+ */
+async function csvToJsonAsync(csv: string, options: CsvToJsonOptions = {}): Promise<any[]> {
+  return csvToJson(csv, options);
+}
+
+/**
+ * Асинхронная версия parseCsvFile
+ */
+async function parseCsvFileAsync(file: File, options: CsvToJsonOptions = {}): Promise<any[]> {
+  return parseCsvFile(file, options);
+}
+
+/**
+ * Асинхронная версия autoDetectDelimiter
+ */
+async function autoDetectDelimiterAsync(csv: string): Promise<string> {
+  return autoDetectDelimiter(csv);
+}
+
+/**
+ * Асинхронная версия downloadAsCsv
+ */
+async function downloadAsCsvAsync(
+  data: any,
+  filename: string = 'export.csv',
+  options: JsonToCsvOptions = {}
+): Promise<void> {
+  return downloadAsCsv(data, filename, options);
+}
+
+// Основной экспорт ядра
+const jtcsvCore = {
+  // JSON to CSV функции
+  jsonToCsv,
+  preprocessData,
+  downloadAsCsv,
+  deepUnwrap,
+  
+  // CSV to JSON функции
+  csvToJson,
+  csvToJsonIterator,
+  parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream,
+  autoDetectDelimiter,
+  
+  // Асинхронные функции
+  jsonToCsvAsync,
+  csvToJsonAsync,
+  parseCsvFileAsync,
+  autoDetectDelimiterAsync,
+  downloadAsCsvAsync,
+  
+  // Error classes
+  ValidationError,
+  SecurityError,
+  FileSystemError,
+  ParsingError,
+  LimitError,
+  ConfigurationError,
+  ERROR_CODES,
+  
+  // Удобные алиасы
+  parse: csvToJson,
+  unparse: jsonToCsv,
+  parseAsync: csvToJsonAsync,
+  unparseAsync: jsonToCsvAsync,
+  
+  // Версия
+  version: '3.0.0-core'
+};
+
+// Экспорт для разных сред
+if (typeof module !== 'undefined' && module.exports) {
+  // Node.js CommonJS
+  module.exports = jtcsvCore;
+} else if (typeof define === 'function' && (define as any).amd) {
+  // AMD
+  (define as any)([], () => jtcsvCore);
+} else if (typeof window !== 'undefined') {
+  // Браузер (глобальная переменная)
+  (window as any).jtcsv = jtcsvCore;
+}
+
+export default jtcsvCore;
+export {
+  jsonToCsv,
+  preprocessData,
+  downloadAsCsv,
+  deepUnwrap,
+  csvToJson,
+  csvToJsonIterator,
+  parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream,
+  autoDetectDelimiter,
+  // Асинхронные функции
+  jsonToCsvAsync,
+  csvToJsonAsync,
+  parseCsvFileAsync,
+  autoDetectDelimiterAsync,
+  downloadAsCsvAsync,
+  // Error classes
+  ValidationError,
+  SecurityError,
+  FileSystemError,
+  ParsingError,
+  LimitError,
+  ConfigurationError,
+  ERROR_CODES
+};

package/src/browser/csv-to-json-browser.d.ts

@@ -0,0 +1,3 @@
+export function csvToJson(csv: string, options?: any): any[];
+export function csvToJsonIterator(input: any, options?: any): AsyncGenerator<any, void, unknown>;
+export function autoDetectDelimiter(csv: string, candidates?: string[]): string;

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

@@ -191,10 +191,18 @@ function parseCsvValue(value, options) {
   }
   
   // Парсинг чисел
-  if (parseNumbers && /^-?\d+(\.\d+)?$/.test(result)) {
-    const num = parseFloat(result);
-    if (!isNaN(num)) {
-      return num;
+  if (parseNumbers) {
+    // Быстрая проверка числа: первый символ цифра, минус или точка
+    const trimmed = result.trim();
+    const firstChar = trimmed.charAt(0);
+    if ((firstChar >= '0' && firstChar <= '9') || firstChar === '-' || firstChar === '.') {
+      const num = parseFloat(trimmed);
+      if (!isNaN(num) && isFinite(num)) {
+        // Убедимся, что строка полностью соответствует числу (без лишних символов)
+        if (String(num) === trimmed || (trimmed.includes('.') && !isNaN(Number(trimmed)))) {
+          return num;
+        }
+      }
     }
   }
   
@@ -327,28 +335,42 @@ export function autoDetectDelimiter(csv, candidates = [';', ',', '\t', '|']) {
   // Использование первой непустой строки для определения
   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;
-  });
+  const candidateSet = new Set(candidates);
+  for (let i = 0; i < firstLine.length; i++) {
+    const char = firstLine[i];
+    if (candidateSet.has(char)) {
+      counts[char] = (counts[char] || 0) + 1;
+    }
+  }
+  // Убедимся, что все кандидаты присутствуют в counts (даже с нулём)
+  for (const delim of candidates) {
+    if (!(delim in counts)) {
+      counts[delim] = 0;
+    }
+  }
 
   // Поиск разделителя с максимальным количеством
   let maxCount = -1;
   let detectedDelimiter = ';'; // значение по умолчанию
+  const maxDelimiters = [];
   
   for (const [delim, count] of Object.entries(counts)) {
     if (count > maxCount) {
       maxCount = count;
-      detectedDelimiter = delim;
+      maxDelimiters.length = 0;
+      maxDelimiters.push(delim);
+    } else if (count === maxCount) {
+      maxDelimiters.push(delim);
     }
   }
 
-  // Если разделитель не найден или ничья
-  if (maxCount === 0) {
-    return ';'; // значение по умолчанию
+  // Если разделитель не найден или есть ничья, возвращаем стандартный
+  if (maxCount === 0 || maxDelimiters.length > 1) {
+    detectedDelimiter = ';';
+  } else {
+    detectedDelimiter = maxDelimiters[0];
   }
 
   return detectedDelimiter;

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

@@ -0,0 +1,264 @@
+// Браузерная версия CSV to JSON конвертера
+// Адаптирована для работы в браузере без Node.js API
+
+import {
+  ValidationError,
+  ParsingError,
+  LimitError,
+  ConfigurationError,
+  safeExecute
+} from './errors-browser';
+
+import type { CsvToJsonOptions } from '../types';
+
+/**
+ * Валидация опций парсинга
+ * @private
+ */
+function validateCsvOptions(options: CsvToJsonOptions): boolean {
+  // Validate options
+  if (options && typeof options !== 'object') {
+    throw new ConfigurationError('Options must be an object');
+  }
+  
+  // Validate delimiter
+  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');
+  }
+  
+  // Validate autoDetect
+  if (options?.autoDetect !== undefined && typeof options.autoDetect !== 'boolean') {
+    throw new ConfigurationError('autoDetect must be a boolean');
+  }
+  
+  // Validate candidates
+  if (options?.candidates && !Array.isArray(options.candidates)) {
+    throw new ConfigurationError('candidates must be an array');
+  }
+  
+  // Validate maxRows
+  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;
+}
+
+/**
+ * Автоматическое определение разделителя
+ * @private
+ */
+function autoDetectDelimiter(text: string, candidates: string[] = [',', ';', '\t', '|']): string {
+  if (!text || typeof text !== 'string') {
+    return ',';
+  }
+  
+  const firstLine = text.split('\n')[0];
+  if (!firstLine) {
+    return ',';
+  }
+  
+  let bestCandidate = ',';
+  let bestCount = 0;
+  
+  for (const candidate of candidates) {
+    const count = (firstLine.match(new RegExp(candidate.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
+    if (count > bestCount) {
+      bestCount = count;
+      bestCandidate = candidate;
+    }
+  }
+  
+  return bestCandidate;
+}
+
+/**
+ * Парсинг CSV строки в массив объектов
+ * 
+ * @param csvText - CSV текст для парсинга
+ * @param options - Опции парсинга
+ * @returns Массив объектов
+ */
+export function csvToJson(csvText: string, options: CsvToJsonOptions = {}): any[] {
+  return safeExecute(() => {
+    validateCsvOptions(options);
+    
+    if (typeof csvText !== 'string') {
+      throw new ValidationError('CSV text must be a string');
+    }
+    
+    if (csvText.trim() === '') {
+      return [];
+    }
+    
+    // Определение разделителя
+    const delimiter = options.delimiter || 
+      (options.autoDetect !== false ? autoDetectDelimiter(csvText, options.candidates) : ',');
+    
+    // Разделение на строки
+    const lines = csvText.split('\n').filter(line => line.trim() !== '');
+    if (lines.length === 0) {
+      return [];
+    }
+    
+    // Парсинг заголовков
+    const headers = lines[0].split(delimiter).map(h => h.trim());
+    
+    // Ограничение количества строк
+    const maxRows = options.maxRows || Infinity;
+    const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
+    
+    // Парсинг данных
+    const result = [];
+    
+    for (let i = 0; i < dataRows.length; i++) {
+      const line = dataRows[i];
+      const values = line.split(delimiter);
+      const row: Record<string, any> = {};
+      
+      for (let j = 0; j < headers.length; j++) {
+        const header = headers[j];
+        const value = j < values.length ? values[j].trim() : '';
+        
+        // Попытка парсинга чисел
+        if (/^-?\d+(\.\d+)?$/.test(value)) {
+          row[header] = parseFloat(value);
+        } else if (value.toLowerCase() === 'true' || value.toLowerCase() === 'false') {
+          row[header] = value.toLowerCase() === 'true';
+        } else {
+          row[header] = value;
+        }
+      }
+      
+      result.push(row);
+    }
+    
+    return result;
+  });
+}
+
+/**
+ * Асинхронная версия csvToJson
+ */
+export async function csvToJsonAsync(csvText: string, options: CsvToJsonOptions = {}): Promise<any[]> {
+  return csvToJson(csvText, options);
+}
+
+/**
+ * Создает итератор для потокового парсинга CSV
+ * 
+ * @param input - CSV текст, File или Blob
+ * @param options - Опции парсинга
+ * @returns AsyncGenerator
+ */
+export async function* csvToJsonIterator(input: string | File | Blob, options: CsvToJsonOptions = {}): AsyncGenerator<any> {
+  validateCsvOptions(options);
+  
+  let csvText: string;
+  
+  if (typeof input === 'string') {
+    csvText = input;
+  } else if (input instanceof File || input instanceof Blob) {
+    csvText = await input.text();
+  } else {
+    throw new ValidationError('Input must be string, File or Blob');
+  }
+  
+  if (csvText.trim() === '') {
+    return;
+  }
+  
+  // Определение разделителя
+  const delimiter = options.delimiter || 
+    (options.autoDetect !== false ? autoDetectDelimiter(csvText, options.candidates) : ',');
+  
+  // Разделение на строки
+  const lines = csvText.split('\n').filter(line => line.trim() !== '');
+  if (lines.length === 0) {
+    return;
+  }
+  
+  // Парсинг заголовков
+  const headers = lines[0].split(delimiter).map(h => h.trim());
+  
+  // Ограничение количества строк
+  const maxRows = options.maxRows || Infinity;
+  const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
+  
+  // Возврат данных по одной строке
+  for (let i = 0; i < dataRows.length; i++) {
+    const line = dataRows[i];
+    const values = line.split(delimiter);
+    const row: Record<string, any> = {};
+    
+    for (let j = 0; j < headers.length; j++) {
+      const header = headers[j];
+      const value = j < values.length ? values[j].trim() : '';
+      
+      // Попытка парсинга чисел
+      if (/^-?\d+(\.\d+)?$/.test(value)) {
+        row[header] = parseFloat(value);
+      } else if (value.toLowerCase() === 'true' || value.toLowerCase() === 'false') {
+        row[header] = value.toLowerCase() === 'true';
+      } else {
+        row[header] = value;
+      }
+    }
+    
+    yield row;
+  }
+}
+
+/**
+ * Асинхронная версия csvToJsonIterator (псевдоним)
+ */
+export const csvToJsonIteratorAsync = csvToJsonIterator;
+
+/**
+ * Парсинг CSV с обработкой ошибок
+ * 
+ * @param csvText - CSV текст
+ * @param options - Опции парсинга
+ * @returns Результат парсинга или null при ошибке
+ */
+export function parseCsvSafe(csvText: string, options: CsvToJsonOptions = {}): any[] | null {
+  try {
+    return csvToJson(csvText, options);
+  } catch (error) {
+    console.error('CSV parsing error:', error);
+    return null;
+  }
+}
+
+/**
+ * Асинхронная версия parseCsvSafe
+ */
+export async function parseCsvSafeAsync(csvText: string, options: CsvToJsonOptions = {}): Promise<any[] | null> {
+  try {
+    return await csvToJsonAsync(csvText, options);
+  } catch (error) {
+    console.error('CSV parsing error:', error);
+    return null;
+  }
+}
+
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    csvToJson,
+    csvToJsonAsync,
+    csvToJsonIterator,
+    csvToJsonIteratorAsync,
+    parseCsvSafe,
+    parseCsvSafeAsync,
+    autoDetectDelimiter
+  };
+}