@cj-tech-master/excelts 1.6.3-canary.20251224124621.73c5d94 → 1.6.3

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

@@ -1,202 +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 { Unzip, UnzipInflate } from "fflate";
-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);
-        }
-        const allFiles = {};
-        await new Promise((resolve, reject) => {
-            let filesProcessed = 0;
-            let zipEnded = false;
-            let filesStarted = 0;
-            const checkCompletion = () => {
-                if (zipEnded && filesProcessed === filesStarted) {
-                    resolve();
-                }
-            };
-            const unzipper = new Unzip((file) => {
-                filesStarted++;
-                const fileChunks = [];
-                let totalLength = 0;
-                file.ondata = (err, fileData, final) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    if (fileData) {
-                        fileChunks.push(fileData);
-                        totalLength += fileData.length;
-                    }
-                    if (final) {
-                        if (fileChunks.length === 1) {
-                            allFiles[file.name] = fileChunks[0];
-                        }
-                        else if (fileChunks.length > 1) {
-                            const fullData = new Uint8Array(totalLength);
-                            let offset = 0;
-                            for (const chunk of fileChunks) {
-                                fullData.set(chunk, offset);
-                                offset += chunk.length;
-                            }
-                            allFiles[file.name] = fullData;
-                        }
-                        else {
-                            allFiles[file.name] = new Uint8Array(0);
-                        }
-                        filesProcessed++;
-                        fileChunks.length = 0;
-                        checkCompletion();
-                    }
-                };
-                file.start();
-            });
-            unzipper.register(UnzipInflate);
-            unzipper.push(buffer, true);
-            zipEnded = true;
-            checkCompletion();
-        });
-        return this.loadFromFiles(allFiles, 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/types/csv/csv-core.d.ts

@@ -1,207 +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.
- *
- * Compatible with fast-csv API for drop-in replacement.
- *
- * @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);
-/** Validation result */
-export interface RowValidationResult<T = Row> {
-    row: T | null;
-    isValid: boolean;
-    reason?: string;
-}
-/**
- * CSV parsing options - compatible with fast-csv
- */
-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) - same as fast-csv ignoreEmpty */
-    skipEmptyLines?: boolean;
-    /** Alias for skipEmptyLines for fast-csv compatibility */
-    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 - compatible with fast-csv
- */
-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" for fast-csv compatibility) */
-    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;

package/dist/types/csv/csv.base.d.ts

@@ -1,61 +0,0 @@
-/**
- * CSV Base class - Shared functionality for Node.js and Browser
- *
- * Uses native CSV parser (RFC 4180 compliant) with zero external dependencies.
- * Date parsing uses dayjs for format flexibility.
- */
-import { type CsvParseOptions, type CsvFormatOptions } from "./csv-core";
-import type { Workbook } from "../doc/workbook";
-import type { Worksheet } from "../doc/worksheet";
-/**
- * CSV read options
- */
-export interface CsvReadOptions {
-    /** Date format strings to try when parsing (default: ISO formats) */
-    dateFormats?: string[];
-    /** Custom value mapper function */
-    map?(value: any, index: number): any;
-    /** Worksheet name to create (default: "Sheet1") */
-    sheetName?: string;
-    /** CSV parsing options */
-    parserOptions?: Partial<CsvParseOptions>;
-}
-/**
- * CSV write options
- */
-export interface CsvWriteOptions {
-    /** Date format for output (default: ISO format) */
-    dateFormat?: string;
-    /** Use UTC for dates (default: false) */
-    dateUTC?: boolean;
-    /** Worksheet name or ID to export */
-    sheetName?: string;
-    /** Worksheet ID to export */
-    sheetId?: number;
-    /** Output encoding (default: "utf8") */
-    encoding?: string;
-    /** Custom value mapper function */
-    map?(value: any, index: number): any;
-    /** Include empty rows (default: true) */
-    includeEmptyRows?: boolean;
-    /** CSV formatting options */
-    formatterOptions?: Partial<CsvFormatOptions>;
-}
-/**
- * Create the default value mapper for CSV parsing
- */
-export declare function createDefaultValueMapper(dateFormats: string[]): (datum: any) => any;
-/**
- * Create the default value mapper for CSV writing
- */
-export declare function createDefaultWriteMapper(dateFormat?: string, dateUTC?: boolean): (value: any) => any;
-/**
- * Parse CSV content into a worksheet
- */
-export declare function parseCsvToWorksheet(content: string, workbook: Workbook, options?: CsvReadOptions): Worksheet;
-/**
- * Format worksheet as CSV string
- */
-export declare function formatWorksheetToCsv(worksheet: Worksheet | undefined, options?: CsvWriteOptions): string;
-export { parseCsv, formatCsv, parseCsvStream } from "./csv-core";
-export type { CsvParseOptions, CsvFormatOptions, CsvParseResult } from "./csv-core";

package/dist/types/csv/csv.browser.d.ts

@@ -1,33 +0,0 @@
-/**
- * CSV class for Browser - No file system dependencies
- *
- * Provides:
- * - load: Load from string or ArrayBuffer
- * - writeString: Write to string
- * - writeBuffer: Write to Uint8Array
- */
-import { type CsvReadOptions, type CsvWriteOptions } from "./csv.base";
-import type { Workbook } from "../doc/workbook.browser";
-import type { Worksheet } from "../doc/worksheet";
-declare class CSV {
-    workbook: Workbook;
-    constructor(workbook: Workbook);
-    /**
-     * Load CSV from string or ArrayBuffer
-     */
-    load(data: string | ArrayBuffer | Uint8Array, options?: CsvReadOptions): Worksheet;
-    /**
-     * Write CSV to string
-     */
-    writeString(options?: CsvWriteOptions): string;
-    /**
-     * Write CSV to Uint8Array buffer
-     */
-    writeBuffer(options?: CsvWriteOptions): Uint8Array;
-    readFile(_filename: string, _options?: CsvReadOptions): Promise<never>;
-    read(_stream: any, _options?: CsvReadOptions): Promise<never>;
-    writeFile(_filename: string, _options?: CsvWriteOptions): Promise<never>;
-    write(_stream: any, _options?: CsvWriteOptions): Promise<never>;
-}
-export { CSV };
-export type { CsvReadOptions, CsvWriteOptions } from "./csv.base";