@cj-tech-master/excelts 3.1.0 → 4.0.0-canary.20260103013222.0e5d37f

package/dist/browser/modules/excel/xlsx/xlsx.d.ts

@@ -0,0 +1,24 @@
+/**
+ * XLSX - Node.js version with full functionality
+ *
+ * Extends XLSX with:
+ * - readFile: Read from file path
+ * - writeFile: Write to file path
+ * - Constructor injects readFileAsync for filename-based media loading
+ *
+ * Inherited from XLSX:
+ * - read: Read from stream
+ * - write: Write to stream
+ * - load: Load from buffer
+ * - writeBuffer: Write to buffer (Uint8Array)
+ * - addMedia: Supports buffer, base64, and filename (via readFileAsync)
+ */
+import { XLSX as XLSXBase } from "@excel/xlsx/xlsx.browser";
+declare class XLSX extends XLSXBase {
+    constructor(workbook: any);
+    private static iterateZipEntries;
+    read(stream: any, options?: any): Promise<any>;
+    readFile(filename: string, options?: any): Promise<any>;
+    writeFile(filename: string, options?: any): Promise<void>;
+}
+export { XLSX };

package/dist/browser/modules/excel/xlsx/xlsx.js

@@ -0,0 +1,239 @@
+/**
+ * XLSX - Node.js version with full functionality
+ *
+ * Extends XLSX with:
+ * - readFile: Read from file path
+ * - writeFile: Write to file path
+ * - Constructor injects readFileAsync for filename-based media loading
+ *
+ * Inherited from XLSX:
+ * - read: Read from stream
+ * - write: Write to stream
+ * - load: Load from buffer
+ * - writeBuffer: Write to buffer (Uint8Array)
+ * - addMedia: Supports buffer, base64, and filename (via readFileAsync)
+ */
+import fs from "fs";
+import { fileExists } from "../../../utils/utils.browser.js";
+import { XLSX as XLSXBase } from "./xlsx.browser.js";
+import { Parse } from "../../archive/index.browser.js";
+import { Writable, pipeline } from "../../stream/index.browser.js";
+class XLSX extends XLSXBase {
+    constructor(workbook) {
+        super(workbook);
+        // Provide file reading capability for addMedia
+        this.readFileAsync = (filename) => fs.promises.readFile(filename);
+    }
+    static async *iterateZipEntries(parser) {
+        const queue = [];
+        let head = 0;
+        let done = false;
+        let error;
+        let notify = null;
+        const wake = () => {
+            if (notify) {
+                const fn = notify;
+                notify = null;
+                fn();
+            }
+        };
+        parser.on("entry", (entry) => {
+            queue.push(entry);
+            wake();
+        });
+        parser.once("error", (err) => {
+            error = err;
+            wake();
+        });
+        parser.once("close", () => {
+            done = true;
+            wake();
+        });
+        while (!done || head < queue.length) {
+            if (error) {
+                throw error;
+            }
+            if (head < queue.length) {
+                const entry = queue[head++];
+                // Periodically compact to avoid unbounded growth.
+                if (head > 1024 && head > queue.length / 2) {
+                    queue.splice(0, head);
+                    head = 0;
+                }
+                yield entry;
+                continue;
+            }
+            await new Promise(resolve => {
+                notify = resolve;
+            });
+        }
+    }
+    // ==========================================================================
+    // Node.js specific: TRUE streaming read
+    // ==========================================================================
+    async read(stream, options) {
+        const parser = new Parse();
+        const swallowError = () => {
+            // Prevent unhandled 'error' events from crashing the process.
+            // Errors are surfaced via rejected promises.
+        };
+        // Always attach an error listener to avoid uncaught exceptions.
+        parser.on("error", swallowError);
+        if (stream && typeof stream.on === "function") {
+            stream.on("error", swallowError);
+        }
+        // Pump incoming data into the ZIP parser without buffering the whole file.
+        // NOTE: `Parse` is a Duplex; passing it directly to pipeline() can make
+        // Node treat it like a transform and surface `Premature close` errors.
+        // We instead pipeline the input stream into a Writable sink that forwards
+        // chunks into the parser with backpressure.
+        const sink = new Writable({
+            write(chunk, _encoding, callback) {
+                try {
+                    const ok = parser.write(chunk);
+                    if (ok) {
+                        callback();
+                    }
+                    else {
+                        parser.once("drain", () => callback());
+                    }
+                }
+                catch (e) {
+                    callback(e);
+                }
+            },
+            final(callback) {
+                try {
+                    parser.end();
+                    callback();
+                }
+                catch (e) {
+                    callback(e);
+                }
+            }
+        });
+        const onParserError = (err) => {
+            try {
+                sink.destroy(err);
+            }
+            catch {
+                // ignore
+            }
+        };
+        parser.on("error", onParserError);
+        const pump = pipeline(stream, sink);
+        const entries = (async function* () {
+            for await (const entry of XLSX.iterateZipEntries(parser)) {
+                entry.on("error", swallowError);
+                const drain = async () => {
+                    const anyEntry = entry;
+                    if (anyEntry?.readableEnded || anyEntry?.destroyed) {
+                        return;
+                    }
+                    const draining = entry.autodrain();
+                    await draining.promise();
+                };
+                yield {
+                    name: entry.path,
+                    type: entry.type,
+                    stream: entry,
+                    drain
+                };
+            }
+        })();
+        try {
+            const workbook = await this.loadFromZipEntries(entries, options);
+            await pump;
+            return workbook;
+        }
+        catch (err) {
+            // Stop the ZIP parser so pipeline() can unwind promptly.
+            try {
+                parser.destroy();
+            }
+            catch {
+                // ignore
+            }
+            // Ensure pump settles to avoid unhandled rejections.
+            try {
+                await pump;
+            }
+            catch {
+                // ignore pump failures; the original parse error is more useful
+            }
+            throw err;
+        }
+        finally {
+            try {
+                parser.off("error", onParserError);
+            }
+            catch {
+                // ignore
+            }
+            try {
+                parser.off("error", swallowError);
+            }
+            catch {
+                // ignore
+            }
+            if (stream && typeof stream.off === "function") {
+                try {
+                    stream.off("error", swallowError);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    // ===========================================================================
+    // 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);
+        return this.read(stream, options);
+    }
+    writeFile(filename, options) {
+        const stream = fs.createWriteStream(filename);
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const cleanup = () => {
+                stream.off("finish", onFinish);
+                stream.off("error", onError);
+                stream.off("close", onClose);
+            };
+            const onFinish = () => {
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+            };
+            const onError = (error) => {
+                if (!settled) {
+                    settled = true;
+                    reject(error);
+                }
+            };
+            const onClose = () => {
+                cleanup();
+            };
+            stream.once("finish", onFinish);
+            stream.once("error", onError);
+            stream.once("close", onClose);
+            this.write(stream, options).catch(err => {
+                if (!settled) {
+                    settled = true;
+                    reject(err);
+                }
+                // Ensure the underlying FD is closed on failure. Keep listeners
+                // attached until the stream closes, otherwise the emitted 'error'
+                // event can become an uncaught exception.
+                stream.destroy(err);
+            });
+        });
+    }
+}
+export { XLSX };

package/dist/browser/modules/stream/base-transform.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Base Transform Stream
+ *
+ * Provides a base class for Transform streams.
+ * Works identically in both browser and Node.js environments.
+ */
+import { EventEmitter } from "@stream/event-emitter";
+export interface BaseTransformOptions {
+    /** High water mark for backpressure */
+    highWaterMark?: number;
+    /** Enable object mode (non-binary data) */
+    objectMode?: boolean;
+}
+export type TransformCallback<T = Uint8Array> = (error?: Error | null, data?: T) => void;
+/**
+ * Browser-compatible Base Transform stream
+ */
+export declare abstract class BaseTransform<TInput = Uint8Array, TOutput = Uint8Array> extends EventEmitter {
+    protected _buffer: TInput[];
+    protected _bufferIndex: number;
+    protected _isProcessing: boolean;
+    protected _isDestroyed: boolean;
+    protected _isFinished: boolean;
+    protected _errorEmitted: boolean;
+    protected _objectMode: boolean;
+    protected _highWaterMark: number;
+    constructor(options?: BaseTransformOptions);
+    /**
+     * Main transform implementation - must be overridden by subclasses
+     */
+    abstract processChunk(chunk: TInput, callback: TransformCallback<TOutput>): void;
+    /**
+     * Optional flush implementation for remaining data
+     */
+    processFlush(callback: TransformCallback<TOutput>): void;
+    /**
+     * Write data to the transform stream
+     */
+    write(chunk: TInput): boolean;
+    /**
+     * Signal end of input
+     */
+    end(chunk?: TInput): void;
+    /**
+     * Destroy the stream
+     */
+    destroy(error?: Error): void;
+    /**
+     * Process next chunk in buffer
+     */
+    private _processNext;
+    /**
+     * Emit error only once
+     */
+    private _emitError;
+    /**
+     * Check if stream is in a valid state
+     */
+    get isValid(): boolean;
+    /**
+     * Check if stream has finished
+     */
+    get isFinished(): boolean;
+    /**
+     * Pipe to another transform or collector
+     */
+    pipe<T extends BaseTransform<TOutput, any>>(destination: T): T;
+}

package/dist/browser/modules/stream/base-transform.js

@@ -0,0 +1,160 @@
+/**
+ * Base Transform Stream
+ *
+ * Provides a base class for Transform streams.
+ * Works identically in both browser and Node.js environments.
+ */
+import { EventEmitter } from "./event-emitter.js";
+/**
+ * Browser-compatible Base Transform stream
+ */
+export class BaseTransform extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        this._buffer = [];
+        this._bufferIndex = 0;
+        this._isProcessing = false;
+        this._isDestroyed = false;
+        this._isFinished = false;
+        this._errorEmitted = false;
+        this._objectMode = options.objectMode ?? false;
+        this._highWaterMark = options.highWaterMark ?? 16384;
+    }
+    /**
+     * Optional flush implementation for remaining data
+     */
+    processFlush(callback) {
+        callback();
+    }
+    /**
+     * Write data to the transform stream
+     */
+    write(chunk) {
+        if (this._isDestroyed) {
+            this.emit("error", new Error("Cannot write to destroyed stream"));
+            return false;
+        }
+        this._buffer.push(chunk);
+        this._processNext();
+        return this._buffer.length - this._bufferIndex < this._highWaterMark;
+    }
+    /**
+     * Signal end of input
+     */
+    end(chunk) {
+        if (chunk !== undefined) {
+            this.write(chunk);
+        }
+        // Wait for buffer to drain, then flush
+        const checkAndFlush = () => {
+            if (this._buffer.length === this._bufferIndex && !this._isProcessing) {
+                this.processFlush((err, data) => {
+                    if (err) {
+                        this._emitError(err);
+                    }
+                    else if (data !== undefined) {
+                        this.emit("data", data);
+                    }
+                    this._isFinished = true;
+                    this.emit("finish");
+                    this.emit("end");
+                });
+            }
+            else {
+                setTimeout(checkAndFlush, 0);
+            }
+        };
+        checkAndFlush();
+    }
+    /**
+     * Destroy the stream
+     */
+    destroy(error) {
+        if (this._isDestroyed) {
+            return;
+        }
+        this._isDestroyed = true;
+        // Reuse array if possible
+        this._buffer.length = 0;
+        this._bufferIndex = 0;
+        if (error) {
+            this._emitError(error);
+        }
+        this.emit("close");
+    }
+    /**
+     * Process next chunk in buffer
+     */
+    _processNext() {
+        // Combined early exit check
+        if (this._isProcessing || this._isDestroyed || this._bufferIndex >= this._buffer.length) {
+            return;
+        }
+        this._isProcessing = true;
+        const chunk = this._buffer[this._bufferIndex++];
+        // Reset/compact when we consume a lot of the prefix to avoid unbounded growth.
+        if (this._bufferIndex === this._buffer.length) {
+            this._buffer.length = 0;
+            this._bufferIndex = 0;
+        }
+        else if (this._bufferIndex > 1024 && this._bufferIndex * 2 > this._buffer.length) {
+            this._buffer = this._buffer.slice(this._bufferIndex);
+            this._bufferIndex = 0;
+        }
+        try {
+            this.processChunk(chunk, (err, data) => {
+                this._isProcessing = false;
+                if (err) {
+                    this._emitError(err);
+                }
+                else {
+                    if (data !== undefined) {
+                        this.emit("data", data);
+                    }
+                    // Process next chunk
+                    this._processNext();
+                }
+            });
+        }
+        catch (err) {
+            this._isProcessing = false;
+            this._emitError(err);
+        }
+    }
+    /**
+     * Emit error only once
+     */
+    _emitError(error) {
+        if (!this._errorEmitted) {
+            this._errorEmitted = true;
+            this.emit("error", error);
+        }
+    }
+    /**
+     * Check if stream is in a valid state
+     */
+    get isValid() {
+        return !this._isDestroyed && !this._errorEmitted;
+    }
+    /**
+     * Check if stream has finished
+     */
+    get isFinished() {
+        return this._isFinished;
+    }
+    /**
+     * Pipe to another transform or collector
+     */
+    pipe(destination) {
+        this.on("data", chunk => {
+            destination.write(chunk);
+        });
+        this.on("end", () => {
+            destination.end();
+        });
+        this.on("error", err => {
+            destination.destroy(err);
+        });
+        return destination;
+    }
+}

package/dist/browser/modules/stream/buffered-stream.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Buffered Stream
+ *
+ * A Duplex-like stream that manages internal buffering with chunk-based read/write operations.
+ * Works identically in both browser and Node.js environments.
+ */
+import { EventEmitter } from "@stream/event-emitter";
+/**
+ * Represents a chunk of data with copy capabilities
+ */
+export interface DataChunk {
+    readonly length: number;
+    copy(target: Uint8Array, targetOffset: number, offset: number, length: number): number;
+    toUint8Array(): Uint8Array;
+}
+/**
+ * String chunk implementation
+ */
+export declare class StringChunk implements DataChunk {
+    private readonly _data;
+    private _buffer?;
+    constructor(data: string);
+    get length(): number;
+    copy(target: Uint8Array, targetOffset: number, offset: number, length: number): number;
+    toUint8Array(): Uint8Array;
+}
+/**
+ * Uint8Array chunk implementation
+ */
+export declare class BufferChunk implements DataChunk {
+    private readonly _data;
+    constructor(data: Uint8Array);
+    get length(): number;
+    copy(target: Uint8Array, targetOffset: number, offset: number, length: number): number;
+    toUint8Array(): Uint8Array;
+}
+export interface BufferedStreamOptions {
+    /** Batch size for internal read-write buffers */
+    batchSize?: number;
+}
+/**
+ * Browser-compatible Buffered Stream with efficient chunk management
+ */
+export declare class BufferedStream extends EventEmitter {
+    private _chunks;
+    private _chunkReadIndex;
+    private _buffers;
+    private _bufferReadIndex;
+    private readonly _batchSize;
+    private _finished;
+    private _destroyed;
+    private _totalLength;
+    constructor(options?: BufferedStreamOptions);
+    /**
+     * Write data to the stream
+     */
+    write(chunk: Uint8Array | string): boolean;
+    /**
+     * Read data from the stream
+     */
+    read(size?: number): Uint8Array | null;
+    /**
+     * Signal end of writes
+     */
+    end(chunk?: Uint8Array | string): void;
+    /**
+     * Destroy the stream
+     */
+    destroy(error?: Error): void;
+    /**
+     * Get total buffered length
+     */
+    get bufferedLength(): number;
+    /**
+     * Get buffer of specified size from internal buffers
+     */
+    private _getBuffer;
+    /**
+     * Add chunk to internal buffers
+     */
+    private _addChunkToBuffers;
+    /**
+     * Get all buffered data as a single Uint8Array
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Check if stream is finished
+     */
+    get isFinished(): boolean;
+    /**
+     * Check if stream is destroyed
+     */
+    get destroyed(): boolean;
+}