jtcsv 2.1.0 → 2.1.3

package/csv-to-json.js

@@ -17,6 +17,14 @@ const {
   safeExecute
 } = require('./errors');
 
+const { TransformHooks, predefinedHooks } = require('./src/core/transform-hooks');
+const DelimiterCache = require('./src/core/delimiter-cache');
+const FastPathEngine = require('./src/engines/fast-path-engine');
+
+// Глобальный экземпляр кэша для авто-детектирования разделителя
+const globalDelimiterCache = new DelimiterCache(100);
+const globalFastPathEngine = new FastPathEngine();
+
 /**
  * Validates CSV input and options
  * @private
@@ -56,133 +64,50 @@ function validateCsvInput(csv, options) {
     throw new ConfigurationError('maxRows must be a positive number');
   }
   
-  return true;
-}
+  // Validate cache options
+  if (options?.useCache !== undefined && typeof options.useCache !== 'boolean') {
+    throw new ConfigurationError('useCache must be a boolean');
+  }
+  
+  if (options?.cache && !(options.cache instanceof DelimiterCache)) {
+    throw new ConfigurationError('cache must be an instance of DelimiterCache');
+  }
 
-/**
-но * Parses a single CSV line with proper escaping
- * @private
- */
-function parseCsvLine(line, lineNumber, delimiter) {
-  const fields = [];
-  let currentField = '';
-  let insideQuotes = false;
-  let escapeNext = false;
-
-  for (let i = 0; i < line.length; i++) {
-    const char = line[i];
+  if (options?.useFastPath !== undefined && typeof options.useFastPath !== 'boolean') {
+    throw new ConfigurationError('useFastPath must be a boolean');
+  }
+
+  if (options?.fastPathMode !== undefined
+    && options.fastPathMode !== 'objects'
+    && options.fastPathMode !== 'compact'
+    && options.fastPathMode !== 'stream') {
+    throw new ConfigurationError('fastPathMode must be "objects", "compact", or "stream"');
+  }
+
+  // Validate hooks
+  if (options?.hooks) {
+    if (typeof options.hooks !== 'object') {
+      throw new ConfigurationError('hooks must be an object');
+    }
     
-    if (escapeNext) {
-      currentField += char;
-      escapeNext = false;
-      continue;
+    if (options.hooks.beforeConvert && typeof options.hooks.beforeConvert !== 'function') {
+      throw new ConfigurationError('hooks.beforeConvert must be a function');
     }
-
-    if (char === '\\') {
-      if (i + 1 === line.length) {
-        // Backslash at end of line - treat as literal
-        currentField += char;
-      } else if (line[i + 1] === '\\') {
-        // Double backslash - add one backslash to field and skip next
-        currentField += char;
-        i++; // Skip next backslash
-      } else {
-        // Escape next character
-        escapeNext = true;
-      }
-      continue;
+    
+    if (options.hooks.afterConvert && typeof options.hooks.afterConvert !== 'function') {
+      throw new ConfigurationError('hooks.afterConvert must be a function');
     }
-
-    if (char === '"') {
-      if (insideQuotes) {
-        if (i + 1 < line.length && line[i + 1] === '"') {
-          // Could be escaped quote ("") or double quote at end ("")
-          if (i + 2 === line.length) {
-            // This is the pattern "" at the end of the line
-            // First quote is part of field, second is closing quote
-            currentField += '"';
-            i++; // Skip the closing quote
-            insideQuotes = false;
-          } else {
-            // Escaped quote inside quotes ("" -> ")
-            currentField += '"';
-            i++; // Skip next quote
-            // Check if this is the end of the quoted field
-            // Look ahead to see if next char is delimiter or end of line
-            let isEndOfField = false;
-            let j = i + 1;
-            // Skip whitespace
-            while (j < line.length && (line[j] === ' ' || line[j] === '\t')) {
-              j++;
-            }
-            if (j === line.length || line[j] === delimiter) {
-              isEndOfField = true;
-            }
-            
-            if (isEndOfField) {
-              // This is the closing quote
-              insideQuotes = false;
-            }
-          }
-        } else {
-          // Check if this is really the end of the quoted field
-          // Look ahead to see if next char is delimiter or end of line
-          let isEndOfField = false;
-          let j = i + 1;
-          // Skip whitespace
-          while (j < line.length && (line[j] === ' ' || line[j] === '\t')) {
-            j++;
-          }
-          if (j === line.length || line[j] === delimiter) {
-            isEndOfField = true;
-          }
-          
-          if (isEndOfField) {
-            // This is the closing quote
-            insideQuotes = false;
-          } else {
-            // This quote is part of the field content
-            currentField += '"';
-          }
-        }
-      } else {
-        // Start of quoted field
-        insideQuotes = true;
-      }
-      continue;
+    
+    if (options.hooks.perRow && typeof options.hooks.perRow !== 'function') {
+      throw new ConfigurationError('hooks.perRow must be a function');
     }
-
-    if (!insideQuotes && char === delimiter) {
-      // End of field
-      fields.push(currentField);
-      currentField = '';
-      continue;
+    
+    if (options.hooks.transformHooks && !(options.hooks.transformHooks instanceof TransformHooks)) {
+      throw new ConfigurationError('hooks.transformHooks must be an instance of TransformHooks');
     }
-
-    currentField += char;
-  }
-
-  // Handle case where escapeNext is still true at end of line
-  if (escapeNext) {
-    // This happens when line ends with backslash
-    // Add the backslash as literal character
-    currentField += '\\';
   }
-
-  // Add last field
-  fields.push(currentField);
-
-  // Check for unclosed quotes
-  if (insideQuotes) {
-    throw new ParsingError('Unclosed quotes in CSV', lineNumber);
-  }
-
-  // Validate field count consistency
-  if (fields.length === 0) {
-    throw new ParsingError('No fields found', lineNumber);
-  }
-
-  return fields;
+  
+  return true;
 }
 
 /**
@@ -223,63 +148,26 @@ function parseCsvValue(value, options) {
   }
   
   // Parse empty strings as null
-  if (result === '') {
-    return null;
-  }
-  
-  return result;
-}
-
-/**
- * Auto-detect CSV delimiter from content
- * @private
- */
-function autoDetectDelimiter(csv, candidates = [';', ',', '\t', '|']) {
-  if (!csv || typeof csv !== 'string') {
-    return ';'; // default
-  }
-
-  const lines = csv.split('\n').filter(line => line.trim().length > 0);
-  
-  if (lines.length === 0) {
-    return ';'; // default
-  }
-
-  // Use first non-empty line for detection
-  const firstLine = lines[0];
-  
-  const counts = {};
-  candidates.forEach(delim => {
-    // Escape special regex characters
-    const escapedDelim = delim.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const regex = new RegExp(escapedDelim, 'g');
-    const matches = firstLine.match(regex);
-    counts[delim] = matches ? matches.length : 0;
-  });
-
-  // Find delimiter with maximum count
-  let maxCount = -1;
-  let detectedDelimiter = ';'; // default
-  
-  for (const [delim, count] of Object.entries(counts)) {
-    if (count > maxCount) {
-      maxCount = count;
-      detectedDelimiter = delim;
-    }
-  }
-
-  // If no delimiter found or tie, return default
-  if (maxCount === 0) {
-    return ';'; // default
-  }
-
-  return detectedDelimiter;
+  if (result === '') {
+    return null;
+  }
+  
+  return result;
+}
+
+/**
+ * Auto-detect CSV delimiter from content with caching support
+ * @private
+ */
+function autoDetectDelimiter(csv, candidates = [';', ',', '\t', '|'], cache = null) {
+  // Используем статический метод DelimiterCache с поддержкой кэширования
+  return DelimiterCache.autoDetectDelimiter(csv, candidates, cache);
 }
 
 /**
- * Converts CSV string to JSON array
+ * Converts CSV string to JSON array with hooks and caching support
  * 
-  * @param {string} csv - CSV string to convert
+ * @param {string} csv - CSV string to convert
  * @param {Object} [options] - Configuration options
  * @param {string} [options.delimiter] - CSV delimiter character (default: auto-detected)
  * @param {boolean} [options.autoDetect=true] - Auto-detect delimiter if not specified
@@ -290,6 +178,13 @@ function autoDetectDelimiter(csv, candidates = [';', ',', '\t', '|']) {
  * @param {boolean} [options.parseNumbers=false] - Parse numeric values
  * @param {boolean} [options.parseBooleans=false] - Parse boolean values
  * @param {number} [options.maxRows] - Maximum number of rows to process (optional, no limit by default)
+ * @param {boolean} [options.useCache=true] - Use caching for delimiter detection
+ * @param {DelimiterCache} [options.cache] - Custom cache instance (optional)
+ * @param {Object} [options.hooks] - Transform hooks
+ * @param {Function} [options.hooks.beforeConvert] - Hook called before conversion
+ * @param {Function} [options.hooks.afterConvert] - Hook called after conversion
+ * @param {Function} [options.hooks.perRow] - Hook called for each row
+ * @param {TransformHooks} [options.hooks.transformHooks] - TransformHooks instance
  * @returns {Array<Object>} JSON array
  * 
  * @example
@@ -298,7 +193,20 @@ function autoDetectDelimiter(csv, candidates = [';', ',', '\t', '|']) {
  * const csv = `id;name;email\n1;John;john@example.com\n2;Jane;jane@example.com`;
  * const json = csvToJson(csv, {
  *   delimiter: ';',
- *   parseNumbers: true
+ *   parseNumbers: true,
+ *   useCache: true, // Включить кэширование
+ *   hooks: {
+ *     beforeConvert: (data) => {
+ *       console.log('Starting conversion...');
+ *       return data;
+ *     },
+ *     perRow: (row, index) => {
+ *       return { ...row, processed: true, index };
+ *     },
+ *     afterConvert: (data) => {
+ *       return data.filter(item => item.id > 0);
+ *     }
+ *   }
  * });
  */
 function csvToJson(csv, options = {}) {
@@ -315,164 +223,286 @@ function csvToJson(csv, options = {}) {
       hasHeaders = true,
       renameMap = {},
       trim = true,
-      parseNumbers = false,
-      parseBooleans = false,
-      maxRows
-    } = opts;
+      parseNumbers = false,
+      parseBooleans = false,
+      maxRows,
+      useCache = true,
+      cache: customCache,
+      useFastPath = true,
+      fastPathMode = 'objects',
+      hooks = {}
+    } = opts;
+
+    if (fastPathMode === 'stream') {
+      return csvToJsonIterator(csv, { ...opts, useFastPath, fastPathMode: 'objects' });
+    }
+
+    // Выбираем кэш для использования
+    const cacheToUse = useCache ? (customCache || globalDelimiterCache) : null;
+
+    // Create transform hooks system
+    const transformHooks = new TransformHooks();
+    
+    // Add individual hooks if provided
+    if (hooks.beforeConvert) {
+      transformHooks.beforeConvert(hooks.beforeConvert);
+    }
+    
+    if (hooks.afterConvert) {
+      transformHooks.afterConvert(hooks.afterConvert);
+    }
+    
+    if (hooks.perRow) {
+      transformHooks.perRow(hooks.perRow);
+    }
+    
+    // Use provided TransformHooks instance if available
+    const finalHooks = hooks.transformHooks || transformHooks;
+
+    // Apply beforeConvert hooks to CSV string
+    const processedCsv = finalHooks.applyBeforeConvert(csv, { 
+      operation: 'csvToJson',
+      options: opts 
+    });
 
-    // Determine delimiter
+    // Determine delimiter with caching support
     let finalDelimiter = delimiter;
     if (!finalDelimiter && autoDetect) {
-      finalDelimiter = autoDetectDelimiter(csv, candidates);
+      finalDelimiter = autoDetectDelimiter(processedCsv, candidates, cacheToUse);
     }
     finalDelimiter = finalDelimiter || ';'; // fallback
 
     // Handle empty CSV
-    if (csv.trim() === '') {
+    if (processedCsv.trim() === '') {
       return [];
     }
 
-    // Parse CSV with proper handling of quotes and newlines
-    const lines = [];
-    let currentLine = '';
-    let insideQuotes = false;
-    
-    for (let i = 0; i < csv.length; i++) {
-      const char = csv[i];
-      
-      if (char === '"') {
-        if (insideQuotes && i + 1 < csv.length && csv[i + 1] === '"') {
-          // Escaped quote inside quotes ("" -> ")
-          currentLine += '"';
-          i++; // Skip next quote
+    let headers = null;
+    let totalRows = 0;
+    let dataRowIndex = 0;
+    const result = [];
+
+    try {
+      const parseOptions = { delimiter: finalDelimiter };
+      if (useFastPath === false) {
+        parseOptions.forceEngine = 'STANDARD';
+      }
+
+      globalFastPathEngine.parseRows(processedCsv, parseOptions, (fields) => {
+        totalRows++;
+
+        if (!headers) {
+          if (hasHeaders) {
+            headers = fields.map(header => {
+              const trimmed = trim ? header.trim() : header;
+              return renameMap[trimmed] || trimmed;
+            });
+            return;
+          }
+          headers = fields.map((_, index) => `column${index + 1}`);
+        }
+
+        if (!fields || fields.length === 0) {
+          return;
+        }
+
+        if (maxRows && totalRows > maxRows) {
+          throw new LimitError(
+            `CSV size exceeds maximum limit of ${maxRows} rows`,
+            maxRows,
+            totalRows
+          );
+        }
+
+        const fieldCount = Math.min(fields.length, headers.length);
+        let row;
+
+        if (fastPathMode === 'compact') {
+          row = new Array(fieldCount);
+          for (let j = 0; j < fieldCount; j++) {
+            row[j] = parseCsvValue(fields[j], { trim, parseNumbers, parseBooleans });
+          }
         } else {
-          // Toggle quote mode
-          insideQuotes = !insideQuotes;
+          row = {};
+          for (let j = 0; j < fieldCount; j++) {
+            row[headers[j]] = parseCsvValue(fields[j], { trim, parseNumbers, parseBooleans });
+          }
         }
-        currentLine += char;
-        continue;
-      }
-      
-      if (char === '\n' && !insideQuotes) {
-        // End of line (outside quotes)
-        lines.push(currentLine);
-        currentLine = '';
-        continue;
-      }
-      
-      if (char === '\r') {
-        // Ignore carriage return, will be handled by \n
-        continue;
+
+        const processedRow = finalHooks.applyPerRow(row, dataRowIndex, {
+          lineNumber: totalRows,
+          headers,
+          options: opts
+        });
+
+        dataRowIndex++;
+        result.push(processedRow);
+
+        if (fields.length > headers.length && process.env.NODE_ENV === 'development') {
+          console.warn(`[jtcsv] Line ${totalRows}: ${fields.length - headers.length} extra fields ignored`);
+        }
+      });
+    } catch (error) {
+      if (error && error.code === 'FAST_PATH_UNCLOSED_QUOTES') {
+        throw new ParsingError(error.message, error.lineNumber);
       }
-      
-      currentLine += char;
-    }
-    
-    // Add the last line
-    if (currentLine !== '' || insideQuotes) {
-      lines.push(currentLine);
+      throw error;
     }
-    
-    // Check for unclosed quotes
-    // Note: This check is moved to parseCsvLine which has better context
-    // for handling escaped quotes like ""
-    // if (insideQuotes) {
-    //   throw new ParsingError('Unclosed quotes in CSV', lines.length);
-    // }
-    
-    if (lines.length === 0) {
+
+    if (!headers) {
       return [];
     }
 
-    // Show warning for large datasets (optional limit)
-    if (lines.length > 1000000 && !maxRows && process.env.NODE_ENV !== 'test') {
-      console.warn(
-        '⚠️ Warning: Processing >1M records in memory may be slow.\n' +
-        '💡 Consider using createCsvToJsonStream() for better performance with large files.\n' +
-        '📊 Current size: ' + lines.length.toLocaleString() + ' rows\n' +
-        '🔧 Tip: Use { maxRows: N } option to set a custom limit if needed.'
-      );
-    }
+    if (totalRows > 1000000 && !maxRows && process.env.NODE_ENV !== 'test') {
+      console.warn(
+        'Warning: Processing >1M records in memory may be slow.\n' +
+        'Consider using createCsvToJsonStream() for better performance with large files.\n' +
+        'Current size: ' + totalRows.toLocaleString() + ' rows\n' +
+        'Tip: Use { maxRows: N } option to set a custom limit if needed.'
+      );
+    }
+
+    return finalHooks.applyAfterConvert(result, {
+      operation: 'csvToJson',
+      totalRows: result.length,
+      options: opts
+    });
 
-    // Apply optional row limit if specified
-    if (maxRows && lines.length > maxRows) {
-      throw new LimitError(
-        `CSV size exceeds maximum limit of ${maxRows} rows`,
-        maxRows,
-        lines.length
-      );
-    }
+  }, 'PARSE_FAILED', { function: 'csvToJson' });
+}
 
-    let headers = [];
-    let startIndex = 0;
-    
-    // Parse headers if present
-    if (hasHeaders && lines.length > 0) {
-      try {
-        headers = parseCsvLine(lines[0], 1, finalDelimiter).map(header => {
+async function* csvToJsonIterator(csv, options = {}) {
+  validateCsvInput(csv, options);
+
+  const opts = options && typeof options === 'object' ? options : {};
+
+  const {
+    delimiter,
+    autoDetect = true,
+    candidates = [';', ',', '\t', '|'],
+    hasHeaders = true,
+    renameMap = {},
+    trim = true,
+    parseNumbers = false,
+    parseBooleans = false,
+    maxRows,
+    useCache = true,
+    cache: customCache,
+    useFastPath = true,
+    fastPathMode = 'objects',
+    hooks = {}
+  } = opts;
+
+  const cacheToUse = useCache ? (customCache || globalDelimiterCache) : null;
+
+  const transformHooks = new TransformHooks();
+
+  if (hooks.beforeConvert) {
+    transformHooks.beforeConvert(hooks.beforeConvert);
+  }
+
+  if (hooks.afterConvert) {
+    transformHooks.afterConvert(hooks.afterConvert);
+  }
+
+  if (hooks.perRow) {
+    transformHooks.perRow(hooks.perRow);
+  }
+
+  const finalHooks = hooks.transformHooks || transformHooks;
+
+  const processedCsv = finalHooks.applyBeforeConvert(csv, {
+    operation: 'csvToJson',
+    options: opts
+  });
+
+  let finalDelimiter = delimiter;
+  if (!finalDelimiter && autoDetect) {
+    finalDelimiter = autoDetectDelimiter(processedCsv, candidates, cacheToUse);
+  }
+  finalDelimiter = finalDelimiter || ';';
+
+  if (processedCsv.trim() === '') {
+    return;
+  }
+
+  let headers = null;
+  let totalRows = 0;
+  let dataRowIndex = 0;
+
+  const handleFields = (fields, lineNumber) => {
+    if (!headers) {
+      if (hasHeaders) {
+        headers = fields.map(header => {
           const trimmed = trim ? header.trim() : header;
-          // Apply rename map
           return renameMap[trimmed] || trimmed;
         });
-        startIndex = 1;
-      } catch (error) {
-        if (error instanceof ParsingError) {
-          throw new ParsingError(`Failed to parse headers: ${error.message}`, 1);
-        }
-        throw error;
-      }
-    } else {
-      // Generate numeric headers from first line
-      try {
-        const firstLineFields = parseCsvLine(lines[0], 1, finalDelimiter);
-        headers = firstLineFields.map((_, index) => `column${index + 1}`);
-      } catch (error) {
-        if (error instanceof ParsingError) {
-          throw new ParsingError(`Failed to parse first line: ${error.message}`, 1);
-        }
-        throw error;
+        return null;
       }
+      headers = fields.map((_, index) => `column${index + 1}`);
     }
 
-    // Parse data rows
-    const result = [];
-    
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      
-      // Skip empty lines
-      if (line.trim() === '') {
-        continue;
-      }
-      
-      try {
-        const fields = parseCsvLine(line, i + 1, finalDelimiter);
-        
-        // Handle mismatched field count
-        const row = {};
-        const fieldCount = Math.min(fields.length, headers.length);
-        
-        for (let j = 0; j < fieldCount; j++) {
-          row[headers[j]] = parseCsvValue(fields[j], { trim, parseNumbers, parseBooleans });
-        }
-        
-        // Warn about extra fields
-        if (fields.length > headers.length && process.env.NODE_ENV === 'development') {
-          console.warn(`[jtcsv] Line ${i + 1}: ${fields.length - headers.length} extra fields ignored`);
-        }
-        
-        result.push(row);
-      } catch (error) {
-        if (error instanceof ParsingError) {
-          throw new ParsingError(`Line ${i + 1}: ${error.message}`, i + 1);
-        }
-        throw error;
+    if (!fields || fields.length === 0) {
+      return null;
+    }
+
+    const fieldCount = Math.min(fields.length, headers.length);
+    let row;
+
+    const resolvedFastPathMode = fastPathMode === 'stream' ? 'objects' : fastPathMode;
+
+    if (resolvedFastPathMode === 'compact') {
+      row = new Array(fieldCount);
+      for (let j = 0; j < fieldCount; j++) {
+        row[j] = parseCsvValue(fields[j], { trim, parseNumbers, parseBooleans });
+      }
+    } else {
+      row = {};
+      for (let j = 0; j < fieldCount; j++) {
+        row[headers[j]] = parseCsvValue(fields[j], { trim, parseNumbers, parseBooleans });
       }
     }
 
-    return result;
-  }, 'PARSE_FAILED', { function: 'csvToJson' });
-}
+    const processedRow = finalHooks.applyPerRow(row, dataRowIndex, {
+      lineNumber,
+      headers,
+      options: opts
+    });
+
+    dataRowIndex++;
+    return processedRow;
+  };
+
+  try {
+    const parseOptions = { delimiter: finalDelimiter };
+    if (useFastPath === false) {
+      parseOptions.forceEngine = 'STANDARD';
+    }
+
+    for (const fields of globalFastPathEngine.iterateRows(processedCsv, parseOptions)) {
+      totalRows++;
+      if (maxRows && totalRows > maxRows) {
+        throw new LimitError(
+          `CSV size exceeds maximum limit of ${maxRows} rows`,
+          maxRows,
+          totalRows
+        );
+      }
+      const processedRow = handleFields(fields, totalRows);
+      if (processedRow !== undefined && processedRow !== null) {
+        if (fields.length > headers.length && process.env.NODE_ENV === 'development') {
+          console.warn(`[jtcsv] Line ${totalRows}: ${fields.length - headers.length} extra fields ignored`);
+        }
+        yield processedRow;
+      }
+    }
+  } catch (error) {
+    if (error && error.code === 'FAST_PATH_UNCLOSED_QUOTES') {
+      throw new ParsingError(error.message, error.lineNumber);
+    }
+    throw error;
+  }
+}
 
 /**
  * Validates file path for CSV reading
@@ -504,18 +534,22 @@ function validateCsvFilePath(filePath) {
 }
 
 /**
- * Reads CSV file and converts it to JSON array
+ * Reads CSV file and converts it to JSON array with hooks and caching support
  * 
  * @param {string} filePath - Path to CSV file
  * @param {Object} [options] - Configuration options (same as csvToJson)
  * @returns {Promise<Array<Object>>} Promise that resolves to JSON array
  * 
  * @example
- *     const { readCsvAsJson } = require('./csv-to-json');
+ * const { readCsvAsJson } = require('./csv-to-json');
  * 
  * const json = await readCsvAsJson('./data.csv', {
  *   delimiter: ',',
- *   parseNumbers: true
+ *   parseNumbers: true,
+ *   useCache: true,
+ *   hooks: {
+ *     perRow: (row) => ({ ...row, processed: true })
+ *   }
  * });
  */
 async function readCsvAsJson(filePath, options = {}) {
@@ -528,7 +562,7 @@ async function readCsvAsJson(filePath, options = {}) {
     // Read file
     const csvContent = await fs.readFile(safePath, 'utf8');
     
-    // Parse CSV
+    // Parse CSV with hooks and caching
     return csvToJson(csvContent, options);
   } catch (error) {
     // Re-throw parsing errors as-is
@@ -552,7 +586,7 @@ async function readCsvAsJson(filePath, options = {}) {
 }
 
 /**
- * Synchronously reads CSV file and converts it to JSON array
+ * Synchronously reads CSV file and converts it to JSON array with hooks and caching support
  * 
  * @param {string} filePath - Path to CSV file
  * @param {Object} [options] - Configuration options (same as csvToJson)
@@ -568,7 +602,7 @@ function readCsvAsJsonSync(filePath, options = {}) {
     // Read file
     const csvContent = fs.readFileSync(safePath, 'utf8');
     
-    // Parse CSV
+    // Parse CSV with hooks and caching
     return csvToJson(csvContent, options);
   } catch (error) {
     // Re-throw parsing errors as-is
@@ -591,12 +625,52 @@ function readCsvAsJsonSync(filePath, options = {}) {
   }
 }
 
+/**
+ * Creates a new TransformHooks instance
+ * @returns {TransformHooks} New TransformHooks instance
+ */
+function createTransformHooks() {
+  return new TransformHooks();
+}
+
+/**
+ * Creates a new DelimiterCache instance
+ * @param {number} maxSize - Maximum cache size (default: 100)
+ * @returns {DelimiterCache} New DelimiterCache instance
+ */
+function createDelimiterCache(maxSize = 100) {
+  return new DelimiterCache(maxSize);
+}
+
+/**
+ * Gets statistics from the global delimiter cache
+ * @returns {Object} Cache statistics
+ */
+function getDelimiterCacheStats() {
+  return globalDelimiterCache.getStats();
+}
+
+/**
+ * Clears the global delimiter cache
+ */
+function clearDelimiterCache() {
+  globalDelimiterCache.clear();
+}
+
 // Export the functions
 module.exports = {
   csvToJson,
+  csvToJsonIterator,
   readCsvAsJson,
   readCsvAsJsonSync,
-  autoDetectDelimiter
+  autoDetectDelimiter,
+  createTransformHooks,
+  createDelimiterCache,
+  getDelimiterCacheStats,
+  clearDelimiterCache,
+  TransformHooks,
+  DelimiterCache,
+  predefinedHooks
 };
 
 // For ES6 module compatibility