@cj-tech-master/excelts 3.1.0-canary.20260102041828.82ed571 → 3.1.0

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

@@ -0,0 +1,159 @@
+/**
+ * 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

@@ -0,0 +1,214 @@
+/**
+ * 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

@@ -0,0 +1,213 @@
+/**
+ * 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;
+    /**
+     * Decimal separator used when parsing numbers from CSV (default: ".").
+     *
+     * Note: core CSV parsing returns strings; this option is intended for higher-level
+     * consumers (e.g. the default value mapper in csv.base) that convert strings to numbers.
+     */
+    decimalSeparator?: "." | ",";
+    /** 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;
+    /**
+     * Decimal separator used when formatting numbers to CSV (default: ".").
+     * For European-style CSV, this is commonly "," (often together with delimiter ";").
+     */
+    decimalSeparator?: "." | ",";
+    /** 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

@@ -0,0 +1,115 @@
+/**
+ * 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 decimalSeparator;
+    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;