jtcsv 2.2.8 → 3.1.0

package/src/browser/{errors-browser.js → errors-browser.ts}

@@ -1,212 +1,320 @@
-// Система ошибок для браузерной версии jtcsv
-// Адаптирована для работы без Node.js специфичных API
-
-/**
- * Базовый класс ошибки jtcsv
- */
+// Система ошибок для браузерной версии jtcsv
+// Адаптирована для работы без Node.js специфичных API
+
+/**
+ * Детали ошибки
+ */
+export interface ErrorDetails {
+  [key: string]: any;
+  originalError?: Error;
+  lineNumber?: number;
+  limit?: any;
+  actual?: any;
+  hint?: string;
+  docs?: string;
+  context?: any;
+}
+
+/**
+ * Базовый класс ошибки jtcsv
+ */
 export class JTCSVError extends Error {
-  constructor(message, code = 'JTCSV_ERROR', details = {}) {
+  code: string;
+  details: ErrorDetails;
+  hint?: string;
+  docs?: string;
+  context?: any;
+
+  constructor(message: string, code: string = 'JTCSV_ERROR', details: ErrorDetails = {}) {
     super(message);
     this.name = 'JTCSVError';
     this.code = code;
     this.details = details;
+    this.hint = details.hint;
+    this.docs = details.docs;
+    this.context = details.context;
+    
+    // Сохранение stack trace
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, JTCSVError);
+    }
+  }
+}
+
+/**
+ * Ошибка валидации
+ */
+export class ValidationError extends JTCSVError {
+  constructor(message: string, details: ErrorDetails = {}) {
+    super(message, 'VALIDATION_ERROR', details);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Ошибка безопасности
+ */
+export class SecurityError extends JTCSVError {
+  constructor(message: string, details: ErrorDetails = {}) {
+    super(message, 'SECURITY_ERROR', details);
+    this.name = 'SecurityError';
+  }
+}
+
+/**
+ * Ошибка файловой системы (адаптирована для браузера)
+ */
+export class FileSystemError extends JTCSVError {
+  constructor(message: string, originalError?: Error, details: ErrorDetails = {}) {
+    super(message, 'FILE_SYSTEM_ERROR', { ...details, originalError });
+    this.name = 'FileSystemError';
+    
+    if (originalError && (originalError as any).code) {
+      this.code = (originalError as any).code;
+    }
+  }
+}
+
+/**
+ * Ошибка парсинга
+ */
+export class ParsingError extends JTCSVError {
+  lineNumber?: number;
+
+  constructor(message: string, lineNumber?: number, details: ErrorDetails = {}) {
+    super(message, 'PARSING_ERROR', { ...details, lineNumber });
+    this.name = 'ParsingError';
+    this.lineNumber = lineNumber;
+  }
+}
+
+/**
+ * Ошибка превышения лимита
+ */
+export class LimitError extends JTCSVError {
+  limit: any;
+  actual: any;
+
+  constructor(message: string, limit: any, actual: any, details: ErrorDetails = {}) {
+    super(message, 'LIMIT_ERROR', { ...details, limit, actual });
+    this.name = 'LimitError';
+    this.limit = limit;
+    this.actual = actual;
+  }
+}
+
+/**
+ * Ошибка конфигурации
+ */
+export class ConfigurationError extends JTCSVError {
+  constructor(message: string, details: ErrorDetails = {}) {
+    super(message, 'CONFIGURATION_ERROR', details);
+    this.name = 'ConfigurationError';
+  }
+}
+
+/**
+ * Коды ошибок
+ */
+export const ERROR_CODES = {
+  JTCSV_ERROR: 'JTCSV_ERROR',
+  VALIDATION_ERROR: 'VALIDATION_ERROR',
+  SECURITY_ERROR: 'SECURITY_ERROR',
+  FILE_SYSTEM_ERROR: 'FILE_SYSTEM_ERROR',
+  PARSING_ERROR: 'PARSING_ERROR',
+  LIMIT_ERROR: 'LIMIT_ERROR',
+  CONFIGURATION_ERROR: 'CONFIGURATION_ERROR',
+  INVALID_INPUT: 'INVALID_INPUT',
+  SECURITY_VIOLATION: 'SECURITY_VIOLATION',
+  FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+  PARSE_FAILED: 'PARSE_FAILED',
+  SIZE_LIMIT: 'SIZE_LIMIT',
+  INVALID_CONFIG: 'INVALID_CONFIG',
+  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+} as const;
+
+export type ErrorCode = typeof ERROR_CODES[keyof typeof ERROR_CODES];
+
+/**
+ * Безопасное выполнение функции с обработкой ошибок
+ * 
+ * @param fn - Функция для выполнения
+ * @param errorCode - Код ошибки по умолчанию
+ * @param errorDetails - Детали ошибки
+ * @returns Результат выполнения функции
+ */
+export function safeExecute<T>(
+  fn: () => T,
+  errorCode: ErrorCode = 'UNKNOWN_ERROR',
+  errorDetails: ErrorDetails = {}
+): T {
+  try {
+    if (typeof fn === 'function') {
+      return fn();
+    }
+    throw new ValidationError('Function expected');
+  } catch (error) {
+    // Если ошибка уже является JTCSVError, перебросить её
+    if (error instanceof JTCSVError) {
+      throw error;
+    }
+    
+    // Определить тип ошибки на основе сообщения или кода
+    let enhancedError: JTCSVError;
+    const errorMessage = (error as Error).message || String(error);
+    
+    if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
+      enhancedError = new ValidationError(errorMessage, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
+      enhancedError = new SecurityError(errorMessage, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
+      enhancedError = new ParsingError(errorMessage, undefined, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('limit') || errorMessage.includes('Limit')) {
+      enhancedError = new LimitError(errorMessage, null, null, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('configuration') || errorMessage.includes('Configuration')) {
+      enhancedError = new ConfigurationError(errorMessage, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('file') || errorMessage.includes('File')) {
+      enhancedError = new FileSystemError(errorMessage, error as Error, errorDetails);
+    } else {
+      // Общая ошибка
+      enhancedError = new JTCSVError(errorMessage, errorCode, { ...errorDetails, originalError: error as Error });
+    }
+    
+    // Сохранить оригинальный stack trace если возможно
+    if ((error as Error).stack) {
+      enhancedError.stack = (error as Error).stack;
+    }
+    
+    throw enhancedError;
+  }
+}
+
+/**
+ * Асинхронная версия safeExecute
+ */
+export async function safeExecuteAsync<T>(
+  fn: () => Promise<T> | T,
+  errorCode: ErrorCode = 'UNKNOWN_ERROR',
+  errorDetails: ErrorDetails = {}
+): Promise<T> {
+  try {
+    if (typeof fn === 'function') {
+      return await fn();
+    }
+    throw new ValidationError('Function expected');
+  } catch (error) {
+    // Если ошибка уже является JTCSVError, перебросить её
+    if (error instanceof JTCSVError) {
+      throw error;
+    }
+    
+    // Определить тип ошибки
+    let enhancedError: JTCSVError;
+    const errorMessage = (error as Error).message || String(error);
+    
+    if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
+      enhancedError = new ValidationError(errorMessage, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
+      enhancedError = new SecurityError(errorMessage, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
+      enhancedError = new ParsingError(errorMessage, undefined, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('limit') || errorMessage.includes('Limit')) {
+      enhancedError = new LimitError(errorMessage, null, null, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('configuration') || errorMessage.includes('Configuration')) {
+      enhancedError = new ConfigurationError(errorMessage, { ...errorDetails, originalError: error as Error });
+    } else if (errorMessage.includes('file') || errorMessage.includes('File')) {
+      enhancedError = new FileSystemError(errorMessage, error as Error, errorDetails);
+    } else {
+      enhancedError = new JTCSVError(errorMessage, errorCode, { ...errorDetails, originalError: error as Error });
+    }
+    
+    if ((error as Error).stack) {
+      enhancedError.stack = (error as Error).stack;
+    }
+    
+    throw enhancedError;
+  }
+}
+
+/**
+ * Создать сообщение об ошибке
+ */
+export function createErrorMessage(
+  error: Error | JTCSVError,
+  includeStack: boolean = false
+): string {
+  let message = error.message || 'Unknown error';
+  
+  if (error instanceof JTCSVError) {
+    message = `[${error.code}] ${message}`;
     
-    // Сохранение stack trace
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, JTCSVError);
+    if (error instanceof ParsingError && error.lineNumber) {
+      message += ` (line ${error.lineNumber})`;
     }
-  }
-}
-
-/**
- * Ошибка валидации
- */
-export class ValidationError extends JTCSVError {
-  constructor(message, details = {}) {
-    super(message, 'VALIDATION_ERROR', details);
-    this.name = 'ValidationError';
-  }
-}
-
-/**
- * Ошибка безопасности
- */
-export class SecurityError extends JTCSVError {
-  constructor(message, details = {}) {
-    super(message, 'SECURITY_ERROR', details);
-    this.name = 'SecurityError';
-  }
-}
-
-/**
- * Ошибка файловой системы (адаптирована для браузера)
- */
-export class FileSystemError extends JTCSVError {
-  constructor(message, originalError = null, details = {}) {
-    super(message, 'FILE_SYSTEM_ERROR', { ...details, originalError });
-    this.name = 'FileSystemError';
     
-    if (originalError && originalError.code) {
-      this.code = originalError.code;
+    if (error instanceof LimitError && error.limit && error.actual) {
+      message += ` (limit: ${error.limit}, actual: ${error.actual})`;
     }
-  }
-}
-
-/**
- * Ошибка парсинга
- */
-export class ParsingError extends JTCSVError {
-  constructor(message, lineNumber = null, details = {}) {
-    super(message, 'PARSING_ERROR', { ...details, lineNumber });
-    this.name = 'ParsingError';
-    this.lineNumber = lineNumber;
-  }
-}
-
-/**
- * Ошибка превышения лимита
- */
-export class LimitError extends JTCSVError {
-  constructor(message, limit, actual, details = {}) {
-    super(message, 'LIMIT_ERROR', { ...details, limit, actual });
-    this.name = 'LimitError';
-    this.limit = limit;
-    this.actual = actual;
-  }
-}
-
-/**
- * Ошибка конфигурации
- */
-export class ConfigurationError extends JTCSVError {
-  constructor(message, details = {}) {
-    super(message, 'CONFIGURATION_ERROR', details);
-    this.name = 'ConfigurationError';
-  }
-}
-
-export const ERROR_CODES = {
-  JTCSV_ERROR: 'JTCSV_ERROR',
-  VALIDATION_ERROR: 'VALIDATION_ERROR',
-  SECURITY_ERROR: 'SECURITY_ERROR',
-  FILE_SYSTEM_ERROR: 'FILE_SYSTEM_ERROR',
-  PARSING_ERROR: 'PARSING_ERROR',
-  LIMIT_ERROR: 'LIMIT_ERROR',
-  CONFIGURATION_ERROR: 'CONFIGURATION_ERROR',
-  INVALID_INPUT: 'INVALID_INPUT',
-  SECURITY_VIOLATION: 'SECURITY_VIOLATION',
-  FILE_NOT_FOUND: 'FILE_NOT_FOUND',
-  PARSE_FAILED: 'PARSE_FAILED',
-  SIZE_LIMIT: 'SIZE_LIMIT',
-  INVALID_CONFIG: 'INVALID_CONFIG',
-  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
-};
 
-/**
- * Безопасное выполнение функции с обработкой ошибок
- * 
- * @param {Function} fn - Функция для выполнения
- * @param {string} errorCode - Код ошибки по умолчанию
- * @param {Object} errorDetails - Детали ошибки
- * @returns {*} Результат выполнения функции
- */
-export function safeExecute(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
-  try {
-    if (typeof fn === 'function') {
-      return fn();
+    if (error.hint) {
+      message += `\nHint: ${error.hint}`;
     }
-    throw new ValidationError('Function expected');
-  } catch (error) {
-    // Если ошибка уже является JTCSVError, перебросить её
-    if (error instanceof JTCSVError) {
-      throw error;
-    }
-    
-    // Определить тип ошибки на основе сообщения или кода
-    let enhancedError;
-    const errorMessage = error.message || String(error);
-    
-    if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
-      enhancedError = new ValidationError(errorMessage, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
-      enhancedError = new SecurityError(errorMessage, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
-      enhancedError = new ParsingError(errorMessage, null, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('limit') || errorMessage.includes('Limit')) {
-      enhancedError = new LimitError(errorMessage, null, null, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('configuration') || errorMessage.includes('Configuration')) {
-      enhancedError = new ConfigurationError(errorMessage, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('file') || errorMessage.includes('File')) {
-      enhancedError = new FileSystemError(errorMessage, error, errorDetails);
-    } else {
-      // Общая ошибка
-      enhancedError = new JTCSVError(errorMessage, errorCode, { ...errorDetails, originalError: error });
-    }
-    
-    // Сохранить оригинальный stack trace если возможно
-    if (error.stack) {
-      enhancedError.stack = error.stack;
-    }
-    
-    throw enhancedError;
-  }
-}
 
-/**
- * Асинхронная версия safeExecute
- */
-export async function safeExecuteAsync(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
-  try {
-    if (typeof fn === 'function') {
-      return await fn();
-    }
-    throw new ValidationError('Function expected');
-  } catch (error) {
-    // Если ошибка уже является JTCSVError, перебросить её
-    if (error instanceof JTCSVError) {
-      throw error;
-    }
-    
-    // Определить тип ошибки
-    let enhancedError;
-    const errorMessage = error.message || String(error);
-    
-    if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
-      enhancedError = new ValidationError(errorMessage, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
-      enhancedError = new SecurityError(errorMessage, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
-      enhancedError = new ParsingError(errorMessage, null, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('limit') || errorMessage.includes('Limit')) {
-      enhancedError = new LimitError(errorMessage, null, null, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('configuration') || errorMessage.includes('Configuration')) {
-      enhancedError = new ConfigurationError(errorMessage, { ...errorDetails, originalError: error });
-    } else if (errorMessage.includes('file') || errorMessage.includes('File')) {
-      enhancedError = new FileSystemError(errorMessage, error, errorDetails);
-    } else {
-      enhancedError = new JTCSVError(errorMessage, errorCode, { ...errorDetails, originalError: error });
+    if (error.docs) {
+      message += `\nDocs: ${error.docs}`;
     }
-    
-    if (error.stack) {
-      enhancedError.stack = error.stack;
-    }
-    
-    throw enhancedError;
   }
-}
-
-// Экспорт для Node.js совместимости
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = {
-    JTCSVError,
-    ValidationError,
-    SecurityError,
-    FileSystemError,
-    ParsingError,
-    LimitError,
-    ConfigurationError,
-    ERROR_CODES,
-    safeExecute,
-    safeExecuteAsync
-  };
+  
+  if (includeStack && error.stack) {
+    message += `\n${error.stack}`;
+  }
+  
+  return message;
+}
+
+/**
+ * Обработка ошибки
+ */
+export function handleError(
+  error: Error | JTCSVError,
+  options: {
+    log?: boolean;
+    throw?: boolean;
+    format?: boolean;
+  } = {}
+): string {
+  const { log = true, throw: shouldThrow = false, format = true } = options;
+  const message = format ? createErrorMessage(error) : error.message;
+  
+  if (log) {
+    console.error(`[jtcsv] ${message}`);
+    
+    if (error instanceof JTCSVError && error.details) {
+      console.error('Error details:', error.details);
+    }
+  }
+  
+  if (shouldThrow) {
+    throw error;
+  }
+  
+  return message;
+}
+
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    JTCSVError,
+    ValidationError,
+    SecurityError,
+    FileSystemError,
+    ParsingError,
+    LimitError,
+    ConfigurationError,
+    ERROR_CODES,
+    safeExecute,
+    safeExecuteAsync,
+    createErrorMessage,
+    handleError
+  };
 }

package/src/browser/extensions/plugins.ts

@@ -0,0 +1,93 @@
+// Расширение плагинов для jtcsv
+// Подключает все плагины (express, fastify, nextjs и т.д.)
+
+const jtcsvPlugins = {
+  // Плагины будут добавлены динамически при импорте
+  // Это placeholder для будущей реализации
+};
+
+// Динамический импорт плагинов (ленивая загрузка)
+// Пути относительно корня проекта (плагины находятся в plugins/)
+async function loadExpressPlugin() {
+  const mod = await import('../../../plugins/express-middleware/index.js');
+  return mod.default || mod;
+}
+
+async function loadFastifyPlugin() {
+  const mod = await import('../../../plugins/fastify-plugin/index.js');
+  return mod.default || mod;
+}
+
+async function loadNextJsPlugin() {
+  // @ts-ignore - the TS source lives in .tsx, use runtime JS
+  const mod = await import('../../../plugins/nextjs-api/index.js');
+  return mod.default || mod;
+}
+
+async function loadNestJsPlugin() {
+  const mod = await import('../../../plugins/nestjs/index.js');
+  return mod.default || mod;
+}
+
+async function loadRemixPlugin() {
+  const mod = await import('../../../plugins/remix/index.js');
+  return mod.default || mod;
+}
+
+async function loadNuxtPlugin() {
+  const mod = await import('../../../plugins/nuxt/index.js');
+  return mod.default || mod;
+}
+
+async function loadSvelteKitPlugin() {
+  const mod = await import('../../../plugins/sveltekit/index.js');
+  return mod.default || mod;
+}
+
+async function loadHonoPlugin() {
+  const mod = await import('../../../plugins/hono/index.js');
+  return mod.default || mod;
+}
+
+async function loadTrpcPlugin() {
+  const mod = await import('../../../plugins/trpc/index.js');
+  return mod.default || mod;
+}
+
+Object.assign(jtcsvPlugins, {
+  loadExpressPlugin,
+  loadFastifyPlugin,
+  loadNextJsPlugin,
+  loadNestJsPlugin,
+  loadRemixPlugin,
+  loadNuxtPlugin,
+  loadSvelteKitPlugin,
+  loadHonoPlugin,
+  loadTrpcPlugin
+});
+
+// Экспорт
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = jtcsvPlugins;
+} else if (typeof define === 'function' && define.amd) {
+  define([], () => jtcsvPlugins);
+} else if (typeof window !== 'undefined' && window.jtcsv) {
+  // Расширяем глобальный jtcsv, если он существует
+  if (!window.jtcsv.plugins) {
+    window.jtcsv.plugins = {};
+  }
+  Object.assign(window.jtcsv.plugins, jtcsvPlugins);
+}
+
+export default jtcsvPlugins;
+export {
+  loadExpressPlugin,
+  loadFastifyPlugin,
+  loadNextJsPlugin,
+  loadNestJsPlugin,
+  loadRemixPlugin,
+  loadNuxtPlugin,
+  loadSvelteKitPlugin,
+  loadHonoPlugin,
+  loadTrpcPlugin
+};

package/src/browser/extensions/workers.ts

@@ -0,0 +1,39 @@
+// Расширение Web Workers для jtcsv
+// Дополнительный модуль для параллельной обработки больших CSV
+
+import { createWorkerPool, parseCSVWithWorker } from '../workers/worker-pool';
+
+async function createWorkerPoolLazy(options = {}) {
+  const mod = await import('../workers/worker-pool');
+  return mod.createWorkerPool(options);
+}
+
+async function parseCSVWithWorkerLazy(csvInput, options = {}, onProgress = null) {
+  const mod = await import('../workers/worker-pool');
+  return mod.parseCSVWithWorker(csvInput, options, onProgress);
+}
+
+const jtcsvWorkers = {
+  createWorkerPool,
+  parseCSVWithWorker,
+  createWorkerPoolLazy,
+  parseCSVWithWorkerLazy
+};
+
+// Экспорт
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = jtcsvWorkers;
+} else if (typeof define === 'function' && define.amd) {
+  define([], () => jtcsvWorkers);
+} else if (typeof window !== 'undefined' && window.jtcsv) {
+  // Расширяем глобальный jtcsv, если он существует
+  Object.assign(window.jtcsv, jtcsvWorkers);
+}
+
+export default jtcsvWorkers;
+export {
+  createWorkerPool,
+  parseCSVWithWorker,
+  createWorkerPoolLazy,
+  parseCSVWithWorkerLazy
+};

package/src/browser/globals.d.ts

@@ -0,0 +1,5 @@
+declare const define: any;
+
+interface Window {
+  jtcsv: any;
+}