cisv 0.0.27 → 0.0.30

package/LICENSE

@@ -1,7 +1,21 @@
-GNU GENERAL PUBLIC LICENSE
-Version 2, 29 Jul 2025
+MIT License
 
-Sanix-Darker CISV Project
+Copyright (c) 2025 - cisv - sanix-darker.
 
-This project is licensed under the GNU General Public License, Version 2.0 (GPL-2.0).
-You may obtain a copy of the License at https://www.gnu.org/licenses/gpl-2.0.html.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,7 +5,8 @@
 ![License](https://img.shields.io/badge/license-GPL2-blue)
 ![Build](https://img.shields.io/badge/build-passing-brightgreen)
 
-High-performance CSV parser/writer leveraging SIMD instructions and zero-copy memory mapping. Available as both a Node.js native addon and standalone CLI tool with extensive configuration options.
+Cisv is a csv parser on steroids... literally.
+It's a high-performance CSV parser/writer leveraging SIMD instructions and zero-copy memory mapping. Available as both a Node.js native addon and standalone CLI tool with extensive configuration options.
 
 I wrote about basics in a blog post, you can read here :https://sanixdk.xyz/blogs/how-i-accidentally-created-the-fastest-csv-parser-ever-made.
 
@@ -292,6 +293,14 @@ parser
     .transform(5, 'base64_encode')  // Column 5 to base64
     .transform(6, 'hash_sha256');   // Column 6 to SHA256
 
+// Custom fieldname transform :
+parser
+    .transform('name', 'uppercase');
+
+// Custom row transform :
+parser
+    .transformRow((row, rowObj) => {console.log(row}});
+
 // Custom JavaScript transforms
 parser.transform(7, value => new Date(value).toISOString());
 
@@ -455,19 +464,9 @@ cisv -b -d ';' -q "'" --trim european.csv
 - Linux/Unix support only (optimized for x86_64 CPU)
 - Windows support planned for future release
 
-## CONTRIBUTING
-
-Areas of interest:
-- [ ] ARM NEON/SVE optimization improvements (in progress)
-- [ ] Windows native support
-- [ ] Parallel parsing for multi-core systems
-- [ ] Custom memory allocators
-- [ ] Streaming compression support
-- [ ] Additional transform functions
-
 ## LICENSE
 
-GPL2 © [sanix-darker](https://github.com/sanix-darker)
+MIT © [sanix-darker](https://github.com/sanix-darker)
 
 ## ACKNOWLEDGMENTS
 

package/cisv/cisv_addon.cc

@@ -153,6 +153,10 @@ public:
             InstanceMethod("destroy", &CisvParser::Destroy),
             InstanceMethod("setConfig", &CisvParser::SetConfig),
             InstanceMethod("getConfig", &CisvParser::GetConfig),
+            InstanceMethod("transformByName", &CisvParser::TransformByName),
+            InstanceMethod("setHeaderFields", &CisvParser::SetHeaderFields),
+            InstanceMethod("removeTransformByName", &CisvParser::RemoveTransformByName),
+
             StaticMethod("countRows", &CisvParser::CountRows),
             StaticMethod("countRowsWithConfig", &CisvParser::CountRowsWithConfig)
         });
@@ -591,6 +595,187 @@ public:
         return info.This();  // Return this for chaining
     }
 
+Napi::Value TransformByName(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (is_destroyed_) {
+        throw Napi::Error::New(env, "Parser has been destroyed");
+    }
+
+    if (info.Length() < 2) {
+        throw Napi::TypeError::New(env, "Expected field name and transform type/function");
+    }
+
+    if (!info[0].IsString()) {
+        throw Napi::TypeError::New(env, "Field name must be a string");
+    }
+
+    std::string field_name = info[0].As<Napi::String>();
+
+    // Ensure pipeline exists (lazy initialization)
+    rc_->ensurePipeline();
+
+    // Store the environment
+    rc_->env = env;
+
+    // Handle string transform types - using the actual C transformer
+    if (info[1].IsString()) {
+        std::string transform_type = info[1].As<Napi::String>();
+        cisv_transform_type_t type;
+
+        // Map string to C enum
+        if (transform_type == "uppercase") {
+            type = TRANSFORM_UPPERCASE;
+        } else if (transform_type == "lowercase") {
+            type = TRANSFORM_LOWERCASE;
+        } else if (transform_type == "trim") {
+            type = TRANSFORM_TRIM;
+        } else if (transform_type == "to_int" || transform_type == "int") {
+            type = TRANSFORM_TO_INT;
+        } else if (transform_type == "to_float" || transform_type == "float") {
+            type = TRANSFORM_TO_FLOAT;
+        } else if (transform_type == "hash_sha256" || transform_type == "sha256") {
+            type = TRANSFORM_HASH_SHA256;
+        } else if (transform_type == "base64_encode" || transform_type == "base64") {
+            type = TRANSFORM_BASE64_ENCODE;
+        } else {
+            throw Napi::Error::New(env, "Unknown transform type: " + transform_type);
+        }
+
+        // Create context if provided
+        cisv_transform_context_t* ctx = nullptr;
+        if (info.Length() >= 3 && info[2].IsObject()) {
+            Napi::Object context_obj = info[2].As<Napi::Object>();
+            ctx = (cisv_transform_context_t*)calloc(1, sizeof(cisv_transform_context_t));
+
+            // Extract context properties if they exist
+            if (context_obj.Has("key")) {
+                Napi::Value key_val = context_obj.Get("key");
+                if (key_val.IsString()) {
+                    std::string key = key_val.As<Napi::String>();
+                    ctx->key = strdup(key.c_str());
+                    ctx->key_len = key.length();
+                }
+            }
+
+            if (context_obj.Has("iv")) {
+                Napi::Value iv_val = context_obj.Get("iv");
+                if (iv_val.IsString()) {
+                    std::string iv = iv_val.As<Napi::String>();
+                    ctx->iv = strdup(iv.c_str());
+                    ctx->iv_len = iv.length();
+                }
+            }
+        }
+
+        // Add to the C transform pipeline by name
+        if (cisv_transform_pipeline_add_by_name(rc_->pipeline, field_name.c_str(), type, ctx) < 0) {
+            // Clean up context if adding failed
+            if (ctx) {
+                if (ctx->key) free((void*)ctx->key);
+                if (ctx->iv) free((void*)ctx->iv);
+                if (ctx->extra) free(ctx->extra);
+                free(ctx);
+            }
+            throw Napi::Error::New(env, "Failed to add transform for field: " + field_name);
+        }
+
+    } else if (info[1].IsFunction()) {
+        // Handle JavaScript function transforms by name
+        Napi::Function func = info[1].As<Napi::Function>();
+
+        // Add to the C transform pipeline by name
+        if (cisv_transform_pipeline_add_js_by_name(rc_->pipeline, field_name.c_str(), &func) < 0) {
+            throw Napi::Error::New(env, "Failed to add JS transform for field: " + field_name);
+        }
+
+    } else {
+        throw Napi::TypeError::New(env, "Transform must be a string type or function");
+    }
+
+    return info.This();  // Return this for chaining
+}
+
+void SetHeaderFields(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (is_destroyed_) {
+        throw Napi::Error::New(env, "Parser has been destroyed");
+    }
+
+    if (info.Length() != 1 || !info[0].IsArray()) {
+        throw Napi::TypeError::New(env, "Expected array of field names");
+    }
+
+    Napi::Array field_names = info[0].As<Napi::Array>();
+    size_t field_count = field_names.Length();
+
+    // Convert to C array of strings
+    const char** c_field_names = (const char**)malloc(field_count * sizeof(char*));
+    if (!c_field_names) {
+        throw Napi::Error::New(env, "Memory allocation failed");
+    }
+
+    for (size_t i = 0; i < field_count; i++) {
+        Napi::Value field_val = field_names[i];
+        if (!field_val.IsString()) {
+            free(c_field_names);
+            throw Napi::TypeError::New(env, "Field names must be strings");
+        }
+        std::string field_str = field_val.As<Napi::String>();
+        c_field_names[i] = strdup(field_str.c_str());
+    }
+
+    // Ensure pipeline exists
+    rc_->ensurePipeline();
+
+    // Set header fields in the pipeline
+    if (cisv_transform_pipeline_set_header(rc_->pipeline, c_field_names, field_count) < 0) {
+        // Clean up
+        for (size_t i = 0; i < field_count; i++) {
+            free((void*)c_field_names[i]);
+        }
+        free(c_field_names);
+        throw Napi::Error::New(env, "Failed to set header fields");
+    }
+
+    // Clean up temporary array (the pipeline makes copies)
+    for (size_t i = 0; i < field_count; i++) {
+        free((void*)c_field_names[i]);
+    }
+    free(c_field_names);
+}
+
+// Add this method to remove transforms by field name
+Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (is_destroyed_) {
+        throw Napi::Error::New(env, "Parser has been destroyed");
+    }
+
+    if (info.Length() != 1 || !info[0].IsString()) {
+        throw Napi::TypeError::New(env, "Expected field name");
+    }
+
+    std::string field_name = info[0].As<Napi::String>();
+
+    // Remove from JavaScript transforms by finding the field index
+    if (rc_->pipeline && rc_->pipeline->header_fields) {
+        for (size_t i = 0; i < rc_->pipeline->header_count; i++) {
+            if (strcmp(rc_->pipeline->header_fields[i], field_name.c_str()) == 0) {
+                rc_->js_transforms.erase(i);
+                break;
+            }
+        }
+    }
+
+    // TODO: Implement removal of C transforms by name in cisv_transformer.c
+    // For now, this only removes JS transforms
+
+    return info.This();
+}
+
     Napi::Value RemoveTransform(const Napi::CallbackInfo &info) {
         Napi::Env env = info.Env();
 

package/cisv/cisv_transformer.c

@@ -173,6 +173,90 @@ int cisv_transform_pipeline_add_js(
     return 0;
 }
 
+// Set header fields for name-based transforms
+int cisv_transform_pipeline_set_header(
+    cisv_transform_pipeline_t *pipeline,
+    const char **field_names,
+    size_t field_count
+) {
+    if (!pipeline || !field_names || field_count == 0) return -1;
+
+    // Free existing header fields if any
+    if (pipeline->header_fields) {
+        for (size_t i = 0; i < pipeline->header_count; i++) {
+            free(pipeline->header_fields[i]);
+        }
+        free(pipeline->header_fields);
+    }
+
+    // Allocate new header fields array
+    pipeline->header_fields = malloc(field_count * sizeof(char *));
+    if (!pipeline->header_fields) return -1;
+
+    // Copy each field name
+    for (size_t i = 0; i < field_count; i++) {
+        pipeline->header_fields[i] = strdup(field_names[i]);
+        if (!pipeline->header_fields[i]) {
+            // Cleanup on failure
+            for (size_t j = 0; j < i; j++) {
+                free(pipeline->header_fields[j]);
+            }
+            free(pipeline->header_fields);
+            pipeline->header_fields = NULL;
+            return -1;
+        }
+    }
+
+    pipeline->header_count = field_count;
+    return 0;
+}
+
+// Add JavaScript callback transform by field name
+int cisv_transform_pipeline_add_js_by_name(
+    cisv_transform_pipeline_t *pipeline,
+    const char *field_name,
+    void *js_callback
+) {
+    if (!pipeline || !field_name || !js_callback || !pipeline->header_fields) return -1;
+
+    // Find field index by name
+    int field_index = -1;
+    for (size_t i = 0; i < pipeline->header_count; i++) {
+        if (strcmp(pipeline->header_fields[i], field_name) == 0) {
+            field_index = (int)i;
+            break;
+        }
+    }
+
+    if (field_index == -1) return -1; // Field not found
+
+    return cisv_transform_pipeline_add_js(pipeline, field_index, js_callback);
+}
+
+// Add transform by field name
+int cisv_transform_pipeline_add_by_name(
+    cisv_transform_pipeline_t *pipeline,
+    const char *field_name,
+    cisv_transform_type_t type,
+    cisv_transform_context_t *ctx
+) {
+    if (!pipeline || !field_name || !pipeline->header_fields) return -1;
+
+    // Find field index by name
+    int field_index = -1;
+    for (size_t i = 0; i < pipeline->header_count; i++) {
+        if (strcmp(pipeline->header_fields[i], field_name) == 0) {
+            field_index = (int)i;
+            break;
+        }
+    }
+
+    if (field_index == -1) return -1; // Field not found
+
+    return cisv_transform_pipeline_add(pipeline, field_index, type, ctx);
+}
+
+
 // Apply transforms for a field
 cisv_transform_result_t cisv_transform_apply(
     cisv_transform_pipeline_t *pipeline,

package/cisv/cisv_transformer.h

@@ -71,6 +71,7 @@ typedef struct {
     cisv_transform_fn fn;
     cisv_transform_context_t *ctx;
     int field_index;  // -1 for all fields
+    const char *field_name;  // Field name to match (alternative to index)
     void *js_callback;  // For JS callbacks (napi_ref)
 } cisv_transform_t;
 
@@ -87,6 +88,9 @@ typedef struct {
 
     // SIMD alignment
     size_t alignment;
+    // Header field names for mapping
+    char **header_fields;
+    size_t header_count;
 } cisv_transform_pipeline_t;
 
 typedef struct cisv_js_callback {
@@ -99,6 +103,13 @@ typedef struct cisv_js_callback {
 cisv_transform_pipeline_t *cisv_transform_pipeline_create(size_t initial_capacity);
 void cisv_transform_pipeline_destroy(cisv_transform_pipeline_t *pipeline);
 
+// Set header fields for name-based transforms
+int cisv_transform_pipeline_set_header(
+    cisv_transform_pipeline_t *pipeline,
+    const char **field_names,
+    size_t field_count
+);
+
 // Add transforms to pipeline
 int cisv_transform_pipeline_add(
     cisv_transform_pipeline_t *pipeline,
@@ -113,6 +124,21 @@ int cisv_transform_pipeline_add_js(
     void *js_callback
 );
 
+// Add JavaScript callback transform by field name
+int cisv_transform_pipeline_add_js_by_name(
+    cisv_transform_pipeline_t *pipeline,
+    const char *field_name,
+    void *js_callback
+);
+
+// Add transform by field name
+int cisv_transform_pipeline_add_by_name(
+    cisv_transform_pipeline_t *pipeline,
+    const char *field_name,
+    cisv_transform_type_t type,
+    cisv_transform_context_t *ctx
+);
+
 // Apply transforms
 cisv_transform_result_t cisv_transform_apply(
     cisv_transform_pipeline_t *pipeline,

package/index.d.ts

@@ -1,400 +1,280 @@
 declare module 'cisv' {
   /**
-   * Transform types available for CSV field transformation
-   */
-  export enum TransformType {
-    UPPERCASE = 'uppercase',
-    LOWERCASE = 'lowercase',
-    TRIM = 'trim',
-    TO_INT = 'to_int',
-    TO_FLOAT = 'to_float',
-    HASH_SHA256 = 'hash_sha256',
-    BASE64_ENCODE = 'base64_encode',
-    CUSTOM = 'custom'
-  }
-
-  /**
-   * Transform context for advanced transformations
-   */
-  export interface TransformContext {
-    key?: string | Buffer;
-    iv?: string | Buffer;
-    extra?: any;
-  }
-
-  /**
-   * Extended configuration for CSV parsing
+   * Configuration options for the CSV parser
    */
   export interface CisvConfig {
+    /** Field delimiter character (default: ',') */
     delimiter?: string;
+
+    /** Quote character (default: '"') */
     quote?: string;
+
+    /** Escape character (null for RFC4180 "" style, default: null) */
     escape?: string | null;
+
+    /** Comment character to skip lines (default: null) */
     comment?: string | null;
+
+    /** Trim whitespace from fields (default: false) */
     trim?: boolean;
+
+    /** Skip empty lines (default: false) */
     skipEmptyLines?: boolean;
+
+    /** Use relaxed parsing rules (default: false) */
     relaxed?: boolean;
+
+    /** Skip lines with parse errors (default: false) */
     skipLinesWithError?: boolean;
+
+    /** Maximum row size in bytes (0 = unlimited, default: 0) */
     maxRowSize?: number;
+
+    /** Start parsing from line N (1-based, default: 1) */
     fromLine?: number;
+
+    /** Stop parsing at line N (0 = until end, default: 0) */
     toLine?: number;
   }
 
   /**
-   * Options for CSV parsing (legacy alias for CisvConfig)
+   * Parsed row is an array of string values
    */
-  export interface ParseOptions {
-    delimiter?: string;
-    quote?: string;
-    escape?: string;
-    headers?: boolean;
-    skipEmptyLines?: boolean;
-    maxRows?: number;
+  export type ParsedRow = string[];
+
+  /**
+   * Statistics about the parsing operation
+   */
+  export interface ParseStats {
+    /** Number of rows parsed */
+    rowCount: number;
+
+    /** Number of fields per row */
+    fieldCount: number;
+
+    /** Total bytes processed */
+    totalBytes: number;
+
+    /** Time taken to parse in milliseconds */
+    parseTime: number;
+
+    /** Current line number being processed */
+    currentLine: number;
   }
 
   /**
-   * Options for CSV writing
+   * Information about registered transforms
    */
-  export interface WriteOptions {
-    delimiter?: string;
-    quote?: string;
-    escape?: string;
-    headers?: boolean | string[];
-    quoteAll?: boolean;
-    lineEnding?: '\n' | '\r\n';
+  export interface TransformInfo {
+    /** Number of C transforms registered */
+    cTransformCount: number;
+
+    /** Number of JavaScript transforms registered */
+    jsTransformCount: number;
+
+    /** Field indices that have transforms */
+    fieldIndices: number[];
   }
 
   /**
-   * Transform function type for custom transformations
+   * Transform function signature for field transforms
    */
-  export type TransformFunction = (
-    value: string,
-    rowIndex: number,
-    fieldIndex: number
-  ) => string;
+  export type FieldTransformFn = (value: string, fieldIndex: number) => string;
 
   /**
-   * Information about applied transformations
+   * Transform function signature for row transforms
+   * @param row - Array of field values
+   * @param rowObj - Object with field names as keys (if header is known)
+   * @returns Modified row array, object, or null to skip the row
    */
-  export interface TransformInfo {
-    [fieldIndex: number]: TransformType | TransformFunction;
-  }
+  export type RowTransformFn = (
+    row: string[],
+    rowObj?: Record<string, string>
+  ) => string[] | Record<string, string> | null;
 
   /**
-   * Statistics from CSV parsing
+   * Built-in transform types
    */
-  export interface ParseStats {
-    rowCount: number;
-    fieldCount: number;
-    totalBytes: number;
-    parseTime: number;
+  export type TransformType =
+    | 'uppercase'
+    | 'lowercase'
+    | 'trim'
+    | 'to_int'
+    | 'int'
+    | 'to_float'
+    | 'float'
+    | 'hash_sha256'
+    | 'sha256'
+    | 'base64_encode'
+    | 'base64';
+
+  /**
+   * Transform context for advanced transforms
+   */
+  export interface TransformContext {
+    /** Encryption/hash key if needed */
+    key?: string;
+
+    /** Initialization vector */
+    iv?: string;
+
+    /** Extra context data */
+    extra?: any;
   }
 
   /**
-   * Main CSV parser class with transformation pipeline support
+   * High-performance CSV parser with SIMD optimization
    */
   export class cisvParser {
-    constructor(options?: CisvConfig);
+    /**
+     * Create a new CSV parser instance
+     * @param config - Optional configuration options
+     */
+    constructor(config?: CisvConfig);
 
     /**
      * Parse CSV file synchronously
-     * @param path Path to CSV file
-     * @returns Array of rows with string values
+     * @param path - Path to CSV file
+     * @returns Array of parsed rows
      */
-    parseSync(path: string): string[][];
+    parseSync(path: string): ParsedRow[];
 
     /**
      * Parse CSV file asynchronously
-     * @param path Path to CSV file
-     * @returns Promise resolving to array of rows
+     * @param path - Path to CSV file
+     * @returns Promise resolving to array of parsed rows
      */
-    parse(path: string): Promise<string[][]>;
+    parse(path: string): Promise<ParsedRow[]>;
 
     /**
      * Parse CSV string content
-     * @param content CSV string content
-     * @returns Array of rows with string values
+     * @param csv - CSV string content
+     * @returns Array of parsed rows
      */
-    parseString(content: string): string[][];
+    parseString(csv: string): ParsedRow[];
 
     /**
-     * Write chunk of CSV data (for streaming)
-     * @param chunk Buffer containing CSV data
+     * Write chunk of data for streaming parsing
+     * @param chunk - Data chunk as Buffer or string
      */
-    write(chunk: ArrayBufferLike | Buffer | string): void;
+    write(chunk: Buffer | string): void;
 
     /**
-     * Signal end of CSV data stream
+     * Signal end of streaming data
      */
     end(): void;
 
     /**
-     * Get all parsed rows
+     * Get accumulated parsed rows
      * @returns Array of parsed rows
      */
-    getRows(): string[][];
+    getRows(): ParsedRow[];
 
     /**
-     * Clear all parsed rows
+     * Clear accumulated data
      */
     clear(): void;
 
     /**
-     * Update parser configuration
-     * @param config New configuration
+     * Set parser configuration
+     * @param config - Configuration options
      */
     setConfig(config: CisvConfig): void;
 
     /**
      * Get current parser configuration
-     * @returns Parser configuration
+     * @returns Current configuration
      */
     getConfig(): CisvConfig;
 
     /**
-     * Add a transformation to a specific field
-     * @param fieldIndex Index of the field to transform (-1 for all fields)
-     * @param transform Transform type or custom function
-     * @param context Optional transform context
-     * @returns this for chaining
+     * Add field transform by index or name
+     * @param field - Field index (0-based) or field name, use -1 for all fields
+     * @param transform - Transform type or custom function
+     * @param context - Optional transform context
+     * @returns Parser instance for chaining
      */
     transform(
-      fieldIndex: number,
-      transform: TransformType | TransformFunction,
+      field: number | string,
+      transform: TransformType | FieldTransformFn,
       context?: TransformContext
     ): this;
 
     /**
-     * Add multiple transformations at once
-     * @param transforms Map of field indices to transform types/functions
-     * @returns this for chaining
-     */
-    transformMany(transforms: Record<number, TransformType | TransformFunction>): this;
-
-    /**
-     * Remove transformation from a field
-     * @param fieldIndex Index of the field
-     * @returns this for chaining
+     * Add row-level transform
+     * @param transform - Row transform function
+     * @returns Parser instance for chaining
      */
-    removeTransform(fieldIndex: number): this;
+    transformRow(transform: RowTransformFn): this;
 
     /**
-     * Clear all transformations
-     * @returns this for chaining
+     * Set header fields for field name mapping
+     * @param fields - Array of field names
+     * @returns Parser instance for chaining
      */
-    clearTransforms(): this;
-
-    /**
-     * Apply transformations to existing data
-     * @param data Array of rows to transform
-     * @returns Transformed data
-     */
-    applyTransforms(data: string[][]): string[][];
+    setHeader(fields: string[]): this;
 
     /**
-     * Set callback for row processing
-     * @param callback Function called for each row
-     * @returns this for chaining
+     * Remove transform for specific field
+     * @param field - Field index or name
+     * @returns Parser instance for chaining
      */
-    onRow(callback: (row: string[], index: number) => void): this;
+    removeTransform(field: number | string): this;
 
     /**
-     * Set callback for field processing
-     * @param callback Function called for each field
-     * @returns this for chaining
+     * Clear all transforms
+     * @returns Parser instance for chaining
      */
-    onField(callback: (field: string, rowIndex: number, fieldIndex: number) => void): this;
+    clearTransforms(): this;
 
     /**
-     * Get statistics about parsed CSV
-     * @returns Object with row count, field count, etc.
+     * Get parsing statistics
+     * @returns Statistics object
      */
     getStats(): ParseStats;
 
     /**
-     * Get information about applied transformations
-     * @returns Map of field indices to transformation info
+     * Get information about registered transforms
+     * @returns Transform information
      */
     getTransformInfo(): TransformInfo;
 
     /**
-     * Destroy the parser and release resources
+     * Destroy parser and free resources
      */
     destroy(): void;
 
     /**
-     * Count rows in a CSV file without fully parsing
-     * @param path Path to CSV file
+     * Count rows in CSV file without parsing
+     * @param path - Path to CSV file
      * @returns Number of rows
      */
     static countRows(path: string): number;
 
     /**
-     * Count rows with custom configuration
-     * @param path Path to CSV file
-     * @param config Optional parser configuration
+     * Count rows with specific configuration
+     * @param path - Path to CSV file
+     * @param config - Configuration options
      * @returns Number of rows
      */
     static countRowsWithConfig(path: string, config?: CisvConfig): number;
-
-    /**
-     * Create a new parser instance with transforms
-     * @param options Parse options
-     * @returns New parser instance
-     */
-    static create(options?: CisvConfig): cisvParser;
-  }
-
-  /**
-   * CSV Writer class for generating CSV files
-   */
-  export class cisvWriter {
-    constructor(options?: WriteOptions);
-
-    /**
-     * Write CSV data to file
-     * @param path Output file path
-     * @param data Array of rows to write
-     */
-    writeSync(path: string, data: any[][]): void;
-
-    /**
-     * Write CSV data to file asynchronously
-     * @param path Output file path
-     * @param data Array of rows to write
-     * @returns Promise that resolves when complete
-     */
-    write(path: string, data: any[][]): Promise<void>;
-
-    /**
-     * Convert data to CSV string
-     * @param data Array of rows
-     * @returns CSV string
-     */
-    stringify(data: any[][]): string;
-
-    /**
-     * Stream write rows
-     * @param row Single row to write
-     */
-    writeRow(row: any[]): void;
-
-    /**
-     * Finish streaming write
-     */
-    end(): void;
-
-    /**
-     * Generate test CSV data
-     * @param rows Number of rows to generate
-     * @param fields Number of fields per row
-     * @returns Generated data
-     */
-    static generate(rows: number, fields?: number): string[][];
   }
 
   /**
-   * Utility functions
+   * Transform type constants
    */
-  export namespace utils {
-    /**
-     * Detect CSV delimiter from file sample
-     * @param path Path to CSV file
-     * @returns Detected delimiter
-     */
-    export function detectDelimiter(path: string): string;
-
-    /**
-     * Validate CSV file structure
-     * @param path Path to CSV file
-     * @returns Validation result
-     */
-    export function validate(path: string): {
-      valid: boolean;
-      errors?: string[];
-      warnings?: string[];
-    };
-
-    /**
-     * Convert CSV to JSON
-     * @param data CSV data
-     * @param headers Use first row as headers
-     * @returns JSON representation
-     */
-    export function toJSON(data: string[][], headers?: boolean): any[];
-
-    /**
-     * Convert JSON to CSV
-     * @param data JSON data
-     * @returns CSV representation
-     */
-    export function fromJSON(data: any[]): string[][];
-
-    /**
-     * Merge multiple CSV files
-     * @param paths Array of file paths
-     * @param outputPath Output file path
-     * @param options Merge options
-     */
-    export function merge(
-      paths: string[],
-      outputPath: string,
-      options?: {
-        skipHeaders?: boolean;
-        delimiter?: string;
-      }
-    ): void;
-
-    /**
-     * Split CSV file into chunks
-     * @param path Input file path
-     * @param chunkSize Rows per chunk
-     * @param outputPrefix Output file prefix
-     */
-    export function split(
-      path: string,
-      chunkSize: number,
-      outputPrefix: string
-    ): string[];
-  }
-
-  /**
-   * Performance benchmarking utilities
-   */
-  export namespace benchmark {
-    /**
-     * Run performance benchmark
-     * @param path CSV file path
-     * @param iterations Number of iterations
-     * @returns Benchmark results
-     */
-    export function run(
-      path: string,
-      iterations?: number
-    ): {
-      avgTime: number;
-      minTime: number;
-      maxTime: number;
-      throughput: number;
-    };
-
-    /**
-     * Compare parser performance
-     * @param paths Array of file paths
-     * @returns Comparison results
-     */
-    export function compare(paths: string[]): Record<string, any>;
-  }
+  export const TransformType: {
+    readonly UPPERCASE: 'uppercase';
+    readonly LOWERCASE: 'lowercase';
+    readonly TRIM: 'trim';
+    readonly TO_INT: 'to_int';
+    readonly TO_FLOAT: 'to_float';
+    readonly HASH_SHA256: 'hash_sha256';
+    readonly BASE64_ENCODE: 'base64_encode';
+  };
 
   /**
-   * Default export
+   * Library version
    */
-  const cisv: {
-    Parser: typeof cisvParser;
-    Writer: typeof cisvWriter;
-    utils: typeof utils;
-    benchmark: typeof benchmark;
-    TransformType: typeof TransformType;
-  };
-
-  export default cisv;
+  export const version: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cisv",
-  "version": "0.0.27",
+  "version": "0.0.30",
   "description": "The fastest csv parser of the multiverse",
   "author": "sanix<s4nixd@gmail.com>",
   "main": "./build/Release/cisv.node",