@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102043356.6791d4e

package/dist/esm/xlsx/xlsx.browser.js

@@ -1,159 +0,0 @@
-/**
- * XLSX Browser version - No Node.js dependencies
- *
- * Extends XLSXBase with:
- * - load: Load from buffer/ArrayBuffer/Uint8Array
- * - writeBuffer: Write to BrowserBuffer (Uint8Array with toString("base64"))
- *
- * NOT supported:
- * - readFile/writeFile (no file system)
- * - read/write (no streams)
- */
-import { ZipParser } from "../utils/unzip/zip-parser.js";
-import { ZipWriter } from "../utils/zip-stream.browser.js";
-import { StreamBuf } from "../utils/stream-buf.browser.js";
-import { bufferToString } from "../utils/utils.js";
-import { base64ToUint8Array, BrowserBuffer } from "../utils/browser-buffer.js";
-import { XLSXBase } from "./xlsx.base.js";
-/**
- * Simple stream-like wrapper for parsing - implements async iterable
- */
-class SimpleStream {
-    constructor(data) {
-        this.listeners = new Map();
-        this.ended = false;
-        this.data = data;
-    }
-    async *[Symbol.asyncIterator]() {
-        yield this.data;
-    }
-    on(event, callback) {
-        const listeners = this.listeners.get(event) || [];
-        listeners.push(callback);
-        this.listeners.set(event, listeners);
-        if (!this.ended) {
-            this.ended = true;
-            queueMicrotask(() => {
-                this.emit("data", this.data);
-                this.emit("end");
-            });
-        }
-        return this;
-    }
-    removeListener(event, callback) {
-        const listeners = this.listeners.get(event) || [];
-        const index = listeners.indexOf(callback);
-        if (index !== -1) {
-            listeners.splice(index, 1);
-        }
-        return this;
-    }
-    emit(event, ...args) {
-        const listeners = this.listeners.get(event) || [];
-        listeners.forEach(cb => cb(...args));
-    }
-    pipe(dest) {
-        dest.write(this.data instanceof Uint8Array ? this.data : new TextEncoder().encode(this.data));
-        dest.end();
-        return dest;
-    }
-}
-class XLSX extends XLSXBase {
-    // ===========================================================================
-    // Abstract method implementations
-    // ===========================================================================
-    createStreamBuf() {
-        return new StreamBuf();
-    }
-    createBinaryStream(data) {
-        return new SimpleStream(data);
-    }
-    createTextStream(content) {
-        return new SimpleStream(content);
-    }
-    bufferToString(data) {
-        return bufferToString(data);
-    }
-    // ===========================================================================
-    // Browser specific: Buffer operations
-    // ===========================================================================
-    /**
-     * Load workbook from buffer/ArrayBuffer/Uint8Array
-     * This is the main entry point for browser usage
-     */
-    async load(data, options) {
-        let buffer;
-        if (!data ||
-            (typeof data === "object" && !(data instanceof Uint8Array) && !(data instanceof ArrayBuffer))) {
-            throw new Error("Can't read the data of 'the loaded zip file'. Is it in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?");
-        }
-        if (options && options.base64) {
-            buffer = base64ToUint8Array(data.toString());
-        }
-        else if (data instanceof ArrayBuffer) {
-            buffer = new Uint8Array(data);
-        }
-        else if (data instanceof Uint8Array) {
-            buffer = data;
-        }
-        else {
-            buffer = new Uint8Array(data);
-        }
-        // Use native ZipParser for extraction
-        const parser = new ZipParser(buffer);
-        const allFiles = await parser.extractAll();
-        // Convert Map to Record for loadFromFiles
-        const filesRecord = {};
-        for (const [path, content] of allFiles) {
-            filesRecord[path] = content;
-        }
-        return this.loadFromFiles(filesRecord, options);
-    }
-    /**
-     * Write workbook to buffer
-     * Returns a BrowserBuffer which supports toString("base64")
-     */
-    async writeBuffer(options) {
-        options = options || {};
-        const { model } = this.workbook;
-        const zip = new ZipWriter(options.zip);
-        const stream = new StreamBuf();
-        zip.pipe(stream);
-        this.prepareModel(model, options);
-        await this.addContentTypes(zip, model);
-        await this.addOfficeRels(zip, model);
-        await this.addWorkbookRels(zip, model);
-        await this.addWorksheets(zip, model);
-        await this.addSharedStrings(zip, model);
-        this.addDrawings(zip, model);
-        this.addTables(zip, model);
-        this.addPivotTables(zip, model);
-        await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
-        await this.addMedia(zip, model);
-        await Promise.all([this.addApp(zip, model), this.addCore(zip, model)]);
-        await this.addWorkbook(zip, model);
-        await this._finalize(zip);
-        return BrowserBuffer.from(stream.read());
-    }
-    // ===========================================================================
-    // Browser specific: Media handling (no file support)
-    // ===========================================================================
-    async addMedia(zip, model) {
-        await Promise.all(model.media.map(async (medium) => {
-            if (medium.type === "image") {
-                const filename = `xl/media/${medium.name}.${medium.extension}`;
-                if (medium.buffer) {
-                    return zip.append(medium.buffer, { name: filename });
-                }
-                if (medium.base64) {
-                    const dataimg64 = medium.base64;
-                    const content = dataimg64.substring(dataimg64.indexOf(",") + 1);
-                    return zip.append(content, { name: filename, base64: true });
-                }
-                throw new Error("Loading images from filename is not supported in browser");
-            }
-            throw new Error("Unsupported media");
-        }));
-    }
-}
-export { XLSX };

package/dist/esm/xlsx/xlsx.js

@@ -1,214 +0,0 @@
-/**
- * XLSX - Node.js version with full functionality
- *
- * Extends XLSXBase with:
- * - readFile: Read from file path
- * - writeFile: Write to file path
- * - read: Read from stream
- * - write: Write to stream
- * - load: Load from buffer
- * - writeBuffer: Write to buffer
- */
-import fs from "fs";
-import { PassThrough } from "stream";
-import { ZipParser } from "../utils/unzip/zip-parser.js";
-import { ZipWriter } from "../utils/zip-stream.js";
-import { StreamBuf } from "../utils/stream-buf.js";
-import { fileExists, bufferToString } from "../utils/utils.js";
-import { XLSXBase } from "./xlsx.base.js";
-function fsReadFileAsync(filename, options) {
-    return new Promise((resolve, reject) => {
-        fs.readFile(filename, options, (error, data) => {
-            if (error) {
-                reject(error);
-            }
-            else {
-                resolve(data);
-            }
-        });
-    });
-}
-class XLSX extends XLSXBase {
-    // ===========================================================================
-    // Abstract method implementations
-    // ===========================================================================
-    createStreamBuf() {
-        return new StreamBuf();
-    }
-    createBinaryStream(data) {
-        const stream = new PassThrough();
-        stream.end(Buffer.from(data));
-        return stream;
-    }
-    createTextStream(content) {
-        const stream = new PassThrough({
-            readableObjectMode: true,
-            writableObjectMode: true
-        });
-        stream.end(content);
-        return stream;
-    }
-    bufferToString(data) {
-        return bufferToString(data);
-    }
-    // ===========================================================================
-    // Node.js specific: File operations
-    // ===========================================================================
-    async readFile(filename, options) {
-        if (!(await fileExists(filename))) {
-            throw new Error(`File not found: ${filename}`);
-        }
-        const stream = fs.createReadStream(filename);
-        try {
-            const workbook = await this.read(stream, options);
-            stream.close();
-            return workbook;
-        }
-        catch (error) {
-            stream.close();
-            throw error;
-        }
-    }
-    writeFile(filename, options) {
-        const stream = fs.createWriteStream(filename);
-        return new Promise((resolve, reject) => {
-            const cleanup = () => {
-                stream.removeListener("finish", onFinish);
-                stream.removeListener("error", onError);
-            };
-            const onFinish = () => {
-                cleanup();
-                resolve();
-            };
-            const onError = (error) => {
-                cleanup();
-                reject(error);
-            };
-            stream.once("finish", onFinish);
-            stream.on("error", onError);
-            this.write(stream, options)
-                .then(() => {
-                stream.end();
-            })
-                .catch(err => {
-                cleanup();
-                reject(err);
-            });
-        });
-    }
-    // ===========================================================================
-    // Node.js specific: Stream operations
-    // ===========================================================================
-    async read(stream, options) {
-        // Collect all stream data into a single buffer
-        const chunks = [];
-        await new Promise((resolve, reject) => {
-            const onData = (chunk) => {
-                chunks.push(chunk);
-            };
-            const onEnd = () => {
-                stream.removeListener("data", onData);
-                stream.removeListener("end", onEnd);
-                stream.removeListener("error", onError);
-                resolve();
-            };
-            const onError = (err) => {
-                stream.removeListener("data", onData);
-                stream.removeListener("end", onEnd);
-                stream.removeListener("error", onError);
-                reject(err);
-            };
-            stream.on("data", onData);
-            stream.on("end", onEnd);
-            stream.on("error", onError);
-        });
-        // Combine chunks into a single buffer
-        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-        const buffer = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const chunk of chunks) {
-            buffer.set(chunk, offset);
-            offset += chunk.length;
-        }
-        // Use native ZipParser for extraction
-        const parser = new ZipParser(buffer);
-        const filesMap = await parser.extractAll();
-        // Convert Map to Record for loadFromFiles
-        const allFiles = {};
-        for (const [path, content] of filesMap) {
-            allFiles[path] = content;
-        }
-        return this.loadFromFiles(allFiles, options);
-    }
-    async write(stream, options) {
-        options = options || {};
-        const { model } = this.workbook;
-        const zip = new ZipWriter(options.zip);
-        zip.pipe(stream);
-        this.prepareModel(model, options);
-        await this.addContentTypes(zip, model);
-        await this.addOfficeRels(zip, model);
-        await this.addWorkbookRels(zip, model);
-        await this.addWorksheets(zip, model);
-        await this.addSharedStrings(zip, model);
-        this.addDrawings(zip, model);
-        this.addTables(zip, model);
-        this.addPivotTables(zip, model);
-        await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
-        await this.addMedia(zip, model);
-        await Promise.all([this.addApp(zip, model), this.addCore(zip, model)]);
-        await this.addWorkbook(zip, model);
-        return this._finalize(zip);
-    }
-    // ===========================================================================
-    // Node.js specific: Buffer operations
-    // ===========================================================================
-    async load(data, options) {
-        let buffer;
-        if (!data ||
-            (typeof data === "object" &&
-                !Buffer.isBuffer(data) &&
-                !(data instanceof Uint8Array) &&
-                !(data instanceof ArrayBuffer))) {
-            throw new Error("Can't read the data of 'the loaded zip file'. Is it in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?");
-        }
-        if (options && options.base64) {
-            buffer = Buffer.from(data.toString(), "base64");
-        }
-        else {
-            buffer = data;
-        }
-        const stream = new PassThrough();
-        stream.end(buffer);
-        return this.read(stream, options);
-    }
-    async writeBuffer(options) {
-        const stream = new StreamBuf();
-        await this.write(stream, options);
-        return stream.read();
-    }
-    // ===========================================================================
-    // Node.js specific: Media handling with file support
-    // ===========================================================================
-    async addMedia(zip, model) {
-        await Promise.all(model.media.map(async (medium) => {
-            if (medium.type === "image") {
-                const filename = `xl/media/${medium.name}.${medium.extension}`;
-                if (medium.filename) {
-                    const data = await fsReadFileAsync(medium.filename);
-                    return zip.append(data, { name: filename });
-                }
-                if (medium.buffer) {
-                    return zip.append(medium.buffer, { name: filename });
-                }
-                if (medium.base64) {
-                    const dataimg64 = medium.base64;
-                    const content = dataimg64.substring(dataimg64.indexOf(",") + 1);
-                    return zip.append(content, { name: filename, base64: true });
-                }
-            }
-            throw new Error("Unsupported media");
-        }));
-    }
-}
-export { XLSX };

package/dist/types/csv/csv-core.d.ts

@@ -1,201 +0,0 @@
-/**
- * CSV Parser and Formatter - RFC 4180 compliant
- *
- * A lightweight, cross-platform CSV implementation that works in both
- * Node.js and Browser environments with zero dependencies.
- *
- * High-performance RFC 4180 compliant CSV parser and formatter.
- *
- * @see https://tools.ietf.org/html/rfc4180
- */
-/** Header array type (can include undefined to skip columns) */
-export type HeaderArray = (string | undefined | null)[];
-/** Header transform function */
-export type HeaderTransformFunction = (headers: string[]) => HeaderArray;
-/** Row types */
-export type RowArray = string[];
-export type RowMap = Record<string, string>;
-export type Row = RowArray | RowMap;
-/** Row transform callback */
-export type RowTransformCallback<T> = (error?: Error | null, row?: T | null) => void;
-/** Row transform function - sync or async */
-export type RowTransformFunction<I = Row, O = Row> = ((row: I) => O | null) | ((row: I, callback: RowTransformCallback<O>) => void);
-/** Row validate callback */
-export type RowValidateCallback = (error?: Error | null, isValid?: boolean, reason?: string) => void;
-/** Row validate function - sync or async */
-export type RowValidateFunction<T = Row> = ((row: T) => boolean) | ((row: T, callback: RowValidateCallback) => void);
-/**
- * CSV parsing options
- */
-export interface CsvParseOptions {
-    /** Field delimiter (default: ",") */
-    delimiter?: string;
-    /** Quote character (default: '"'), set to false or null to disable quoting */
-    quote?: string | false | null;
-    /** Escape character for quotes (default: '"'), set to false or null to disable */
-    escape?: string | false | null;
-    /** Skip empty lines (default: false) */
-    skipEmptyLines?: boolean;
-    /** Alias for skipEmptyLines */
-    ignoreEmpty?: boolean;
-    /** Trim whitespace from both sides of fields (default: false) */
-    trim?: boolean;
-    /** Left trim whitespace from fields (default: false) */
-    ltrim?: boolean;
-    /** Right trim whitespace from fields (default: false) */
-    rtrim?: boolean;
-    /**
-     * Header handling:
-     * - true: first row is headers, return objects
-     * - false: no headers, return arrays
-     * - string[]: use these as headers
-     * - function: transform first row headers
-     */
-    headers?: boolean | HeaderArray | HeaderTransformFunction;
-    /**
-     * If true and headers is string[], discard first row and use provided headers
-     */
-    renameHeaders?: boolean;
-    /** Comment character - lines starting with this are ignored */
-    comment?: string;
-    /** Maximum number of data rows to parse (excluding header) */
-    maxRows?: number;
-    /** Number of lines to skip at the beginning (before header detection) */
-    skipLines?: number;
-    /** Number of data rows to skip (after header detection) */
-    skipRows?: number;
-    /**
-     * Strict column handling:
-     * - If true, rows with column count mismatch emit 'data-invalid' event
-     * - If false (default), throws error on mismatch (unless discardUnmappedColumns)
-     */
-    strictColumnHandling?: boolean;
-    /**
-     * If true, discard columns that exceed header count
-     * Only valid when headers are specified
-     */
-    discardUnmappedColumns?: boolean;
-    /**
-     * Enable object mode (default: true for Node.js streams)
-     * - true: push row objects/arrays
-     * - false: push JSON strings
-     */
-    objectMode?: boolean;
-    /**
-     * Character encoding for input (default: "utf8")
-     * Only used in Node.js streaming context
-     */
-    encoding?: BufferEncoding;
-    /**
-     * Synchronous transform function to apply to each row after parsing
-     * Return null/undefined to skip the row
-     * Works in both Node.js and Browser environments
-     *
-     * @example
-     * // With headers (row is Record<string, string>)
-     * transform: (row) => ({ ...row, name: row.name.toUpperCase() })
-     *
-     * // Without headers (row is string[])
-     * transform: (row) => [row[0].toUpperCase(), row[1]]
-     */
-    transform?: (row: Row) => Row | null | undefined;
-    /**
-     * Synchronous validate function to check each row
-     * Return false to mark row as invalid (will be in invalidRows)
-     * Can also return { isValid: boolean, reason?: string }
-     * Works in both Node.js and Browser environments
-     *
-     * @example
-     * // With headers
-     * validate: (row) => row.name !== ''
-     *
-     * // With custom reason
-     * validate: (row) => ({ isValid: row.age >= 18, reason: 'Must be adult' })
-     */
-    validate?: (row: Row) => boolean | {
-        isValid: boolean;
-        reason?: string;
-    };
-}
-/**
- * CSV formatting options
- */
-export interface CsvFormatOptions {
-    /** Field delimiter (default: ",") */
-    delimiter?: string;
-    /** Quote character (default: '"'), set to false or null to disable quoting */
-    quote?: string | false | null;
-    /** Escape character (default: same as quote) */
-    escape?: string | false | null;
-    /** Row delimiter (default: "\n") */
-    rowDelimiter?: string;
-    /** Always quote all fields (default: false, only quote when necessary) */
-    alwaysQuote?: boolean;
-    /** Quote specific columns by name or index */
-    quoteColumns?: boolean | boolean[] | Record<string, boolean>;
-    /** Quote header fields */
-    quoteHeaders?: boolean | boolean[] | Record<string, boolean>;
-    /**
-     * Header handling:
-     * - true: auto-detect headers from first object
-     * - false/null: no headers
-     * - string[]: use these as headers
-     */
-    headers?: string[] | boolean | null;
-    /**
-     * Whether to write headers (default: true when headers is provided)
-     * Set to false to suppress header row output
-     */
-    writeHeaders?: boolean;
-    /** Include BOM for UTF-8 (default: false) */
-    writeBOM?: boolean;
-    /** Include final row delimiter (default: true) */
-    includeEndRowDelimiter?: boolean;
-    /** Write headers even when there's no data (default: false) */
-    alwaysWriteHeaders?: boolean;
-    /**
-     * Transform function to apply to each row before formatting
-     * Can be sync (returns row) or async (calls callback)
-     */
-    transform?: RowTransformFunction<Row, Row>;
-    /**
-     * Enable object mode (default: true for Node.js streams)
-     * - true: accept row objects/arrays directly
-     * - false: accept JSON strings
-     */
-    objectMode?: boolean;
-}
-/**
- * Parsed CSV result with headers
- */
-export interface CsvParseResult<T = string[]> {
-    /** Header row (if headers option was true) */
-    headers?: string[];
-    /** Data rows */
-    rows: T[];
-    /** Invalid rows (when strictColumnHandling is true) */
-    invalidRows?: {
-        row: string[];
-        reason: string;
-    }[];
-}
-/**
- * Check if a transform function is synchronous (1 argument) vs async (2 arguments)
- */
-export declare function isSyncTransform<I, O>(transform: RowTransformFunction<I, O>): transform is (row: I) => O | null;
-/**
- * Check if a validate function is synchronous (1 argument) vs async (2 arguments)
- */
-export declare function isSyncValidate<T>(validate: RowValidateFunction<T>): validate is (row: T) => boolean;
-/**
- * Parse a CSV string into rows of fields
- */
-export declare function parseCsv(input: string, options?: CsvParseOptions): string[][] | CsvParseResult<Record<string, string>>;
-/**
- * Format data as a CSV string
- */
-export declare function formatCsv(data: (string | number | boolean | null | undefined)[][] | Record<string, any>[], options?: CsvFormatOptions): string;
-/**
- * Async CSV parser that yields rows one at a time
- */
-export declare function parseCsvStream(input: string | AsyncIterable<string>, options?: CsvParseOptions): AsyncGenerator<string[] | Record<string, string>, void, unknown>;

package/dist/types/csv/csv-stream.d.ts

@@ -1,114 +0,0 @@
-/**
- * CSV Streaming Support for Node.js
- *
- * Provides true streaming CSV parsing and formatting using Node.js streams.
- * This enables processing of large CSV files without loading them entirely into memory.
- */
-import { Transform, type Readable, type TransformCallback } from "stream";
-import type { CsvParseOptions, CsvFormatOptions, RowTransformFunction, RowValidateFunction, Row } from "./csv-core";
-/**
- * Transform stream that parses CSV data row by row
- *
- * @example
- * ```ts
- * const parser = new CsvParserStream({ headers: true });
- * fs.createReadStream('data.csv')
- *   .pipe(parser)
- *   .on('data', (row) => console.log(row));
- * ```
- */
-export declare class CsvParserStream extends Transform {
-    private options;
-    private buffer;
-    private currentRow;
-    private currentField;
-    private inQuotes;
-    private lineNumber;
-    private rowCount;
-    private skippedDataRows;
-    private headerRow;
-    private headersEmitted;
-    private delimiter;
-    private quote;
-    private escape;
-    private quoteEnabled;
-    private _rowTransform;
-    private _rowValidator;
-    private encoding;
-    constructor(options?: CsvParseOptions);
-    /**
-     * Set a transform function to modify rows before emitting
-     * Supports both sync and async transforms
-     */
-    transform<I extends Row = Row, O extends Row = Row>(transformFunction: RowTransformFunction<I, O>): this;
-    /**
-     * Set a validate function to filter rows
-     * Invalid rows emit 'data-invalid' event
-     */
-    validate<T extends Row = Row>(validateFunction: RowValidateFunction<T>): this;
-    _transform(chunk: Buffer | string, encoding: BufferEncoding, callback: TransformCallback): void;
-    _flush(callback: TransformCallback): void;
-    private applyTrim;
-    private processBuffer;
-    private buildRow;
-    private processPendingRows;
-    private transformAndValidateRow;
-    private validateRow;
-    private emitRow;
-}
-/**
- * Options for CSV formatter stream
- */
-export interface CsvFormatterStreamOptions extends CsvFormatOptions {
-    /** Whether input is objects (vs arrays) */
-    objectMode?: boolean;
-}
-/**
- * Transform stream that formats rows to CSV
- *
- * @example
- * ```ts
- * const formatter = new CsvFormatterStream({ headers: ['name', 'age'] });
- * formatter.pipe(fs.createWriteStream('output.csv'));
- * formatter.write(['Alice', 30]);
- * formatter.write(['Bob', 25]);
- * formatter.end();
- * ```
- */
-export declare class CsvFormatterStream extends Transform {
-    private options;
-    private delimiter;
-    private quote;
-    private escape;
-    private rowDelimiter;
-    private quoteEnabled;
-    private alwaysQuote;
-    private headerWritten;
-    private headers;
-    private shouldWriteHeaders;
-    private rowCount;
-    private _rowTransform;
-    constructor(options?: CsvFormatterStreamOptions);
-    /**
-     * Set a transform function to modify rows before formatting
-     */
-    transform<I extends Row = Row, O extends Row = Row>(transformFunction: RowTransformFunction<I, O>): this;
-    _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
-    _flush(callback: TransformCallback): void;
-    private formatAndPush;
-    private formatRow;
-    private shouldQuoteField;
-    private formatField;
-}
-/**
- * Create a readable stream from an array of rows
- */
-export declare function createCsvReadableStream(rows: any[][], options?: CsvFormatOptions): Readable;
-/**
- * Create parser stream factory
- */
-export declare function createCsvParserStream(options?: CsvParseOptions): CsvParserStream;
-/**
- * Create formatter stream factory
- */
-export declare function createCsvFormatterStream(options?: CsvFormatterStreamOptions): CsvFormatterStream;