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

package/dist/esm/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";
+import { XLSX as XLSXBase } from "@excel/xlsx/xlsx.browser";
+import { Parse } from "@archive";
+import { Writable, pipeline } from "@stream";
+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/esm/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 "@stream/event-emitter";
+/**
+ * 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/esm/modules/stream/buffered-stream.js

@@ -0,0 +1,277 @@
+/**
+ * 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";
+import { textEncoder } from "@stream/shared";
+/**
+ * String chunk implementation
+ */
+export class StringChunk {
+    constructor(data) {
+        this._data = data;
+    }
+    get length() {
+        // Cache the buffer on first access
+        return this.toUint8Array().length;
+    }
+    copy(target, targetOffset, offset, length) {
+        const source = this.toUint8Array();
+        const copyLength = Math.min(length, source.length - offset);
+        target.set(source.subarray(offset, offset + copyLength), targetOffset);
+        return copyLength;
+    }
+    toUint8Array() {
+        if (!this._buffer) {
+            this._buffer = textEncoder.encode(this._data);
+        }
+        return this._buffer;
+    }
+}
+/**
+ * Uint8Array chunk implementation
+ */
+export class BufferChunk {
+    constructor(data) {
+        this._data = data;
+    }
+    get length() {
+        return this._data.length;
+    }
+    copy(target, targetOffset, offset, length) {
+        const copyLength = Math.min(length, this._data.length - offset);
+        target.set(this._data.subarray(offset, offset + copyLength), targetOffset);
+        return copyLength;
+    }
+    toUint8Array() {
+        return this._data;
+    }
+}
+/**
+ * Read-Write buffer for efficient chunk management
+ */
+class ReadWriteBuffer {
+    constructor(size) {
+        this.iRead = 0;
+        this.iWrite = 0;
+        this.size = size;
+        this.buffer = new Uint8Array(size);
+    }
+    get length() {
+        return this.iWrite - this.iRead;
+    }
+    get isEOD() {
+        return this.iRead === this.iWrite;
+    }
+    get isFull() {
+        return this.iWrite === this.size;
+    }
+    read(size) {
+        if (size === 0) {
+            return null;
+        }
+        if (size === undefined || size >= this.length) {
+            const buf = this.toUint8Array();
+            this.iRead = this.iWrite;
+            return buf;
+        }
+        const buf = new Uint8Array(size);
+        buf.set(this.buffer.subarray(this.iRead, this.iRead + size));
+        this.iRead += size;
+        return buf;
+    }
+    write(chunk, offset, length) {
+        const size = Math.min(length, this.size - this.iWrite);
+        chunk.copy(this.buffer, this.iWrite, offset, size);
+        this.iWrite += size;
+        return size;
+    }
+    toUint8Array() {
+        if (this.iRead === 0 && this.iWrite === this.size) {
+            return this.buffer;
+        }
+        // Use subarray for zero-copy view when returning whole remaining buffer
+        return this.buffer.subarray(this.iRead, this.iWrite);
+    }
+}
+/**
+ * Browser-compatible Buffered Stream with efficient chunk management
+ */
+export class BufferedStream extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        this._chunks = [];
+        this._chunkReadIndex = 0;
+        this._buffers = [];
+        this._bufferReadIndex = 0;
+        this._finished = false;
+        this._destroyed = false;
+        this._totalLength = 0;
+        this._batchSize = options.batchSize ?? 16384; // 16KB default
+    }
+    /**
+     * Write data to the stream
+     */
+    write(chunk) {
+        if (this._destroyed) {
+            this.emit("error", new Error("Cannot write to destroyed stream"));
+            return false;
+        }
+        const dataChunk = typeof chunk === "string" ? new StringChunk(chunk) : new BufferChunk(chunk);
+        this._chunks.push(dataChunk);
+        this._totalLength += dataChunk.length;
+        return true;
+    }
+    /**
+     * Read data from the stream
+     */
+    read(size) {
+        // Try to satisfy the read from existing buffers
+        let buffer = this._getBuffer(size);
+        if (!buffer) {
+            // Create new buffers from pending chunks
+            while (this._chunkReadIndex < this._chunks.length) {
+                const chunk = this._chunks[this._chunkReadIndex++];
+                this._addChunkToBuffers(chunk);
+            }
+            // Reset/compact chunk queue when drained
+            if (this._chunkReadIndex === this._chunks.length) {
+                this._chunks.length = 0;
+                this._chunkReadIndex = 0;
+            }
+            else if (this._chunkReadIndex > 1024 && this._chunkReadIndex * 2 > this._chunks.length) {
+                this._chunks = this._chunks.slice(this._chunkReadIndex);
+                this._chunkReadIndex = 0;
+            }
+            buffer = this._getBuffer(size);
+        }
+        return buffer;
+    }
+    /**
+     * Signal end of writes
+     */
+    end(chunk) {
+        if (chunk !== undefined) {
+            this.write(chunk);
+        }
+        this._finished = true;
+        this.emit("finish");
+        this.emit("end");
+    }
+    /**
+     * Destroy the stream
+     */
+    destroy(error) {
+        if (this._destroyed) {
+            return;
+        }
+        this._destroyed = true;
+        this._chunks = [];
+        this._chunkReadIndex = 0;
+        this._buffers = [];
+        this._bufferReadIndex = 0;
+        this._totalLength = 0;
+        if (error) {
+            this.emit("error", error);
+        }
+        this.emit("close");
+    }
+    /**
+     * Get total buffered length
+     */
+    get bufferedLength() {
+        return this._totalLength;
+    }
+    /**
+     * Get buffer of specified size from internal buffers
+     */
+    _getBuffer(size) {
+        while (this._bufferReadIndex < this._buffers.length) {
+            const buf = this._buffers[this._bufferReadIndex];
+            if (buf.isEOD) {
+                this._bufferReadIndex++;
+                continue;
+            }
+            // Track length reduction
+            const beforeLen = buf.length;
+            const data = buf.read(size);
+            this._totalLength -= beforeLen - buf.length;
+            if (buf.isEOD) {
+                this._bufferReadIndex++;
+            }
+            // Reset/compact buffer queue occasionally
+            if (this._bufferReadIndex === this._buffers.length) {
+                this._buffers.length = 0;
+                this._bufferReadIndex = 0;
+            }
+            else if (this._bufferReadIndex > 1024 && this._bufferReadIndex * 2 > this._buffers.length) {
+                this._buffers = this._buffers.slice(this._bufferReadIndex);
+                this._bufferReadIndex = 0;
+            }
+            return data;
+        }
+        // Queue drained
+        if (this._bufferReadIndex !== 0) {
+            this._buffers.length = 0;
+            this._bufferReadIndex = 0;
+        }
+        return null;
+    }
+    /**
+     * Add chunk to internal buffers
+     */
+    _addChunkToBuffers(chunk) {
+        let chunkOffset = 0;
+        let chunkLength = chunk.length;
+        while (chunkLength > 0) {
+            if (this._buffers.length === 0 || this._buffers[this._buffers.length - 1].isFull) {
+                this._buffers.push(new ReadWriteBuffer(this._batchSize));
+            }
+            const buffer = this._buffers[this._buffers.length - 1];
+            const written = buffer.write(chunk, chunkOffset, chunkLength);
+            chunkOffset += written;
+            chunkLength -= written;
+        }
+    }
+    /**
+     * Get all buffered data as a single Uint8Array
+     */
+    toUint8Array() {
+        // Fast path: no data
+        if (this._totalLength === 0) {
+            return new Uint8Array(0);
+        }
+        // Allocate exactly once, then copy remaining chunks/buffers.
+        const out = new Uint8Array(this._totalLength);
+        let offset = 0;
+        for (let i = this._chunkReadIndex; i < this._chunks.length; i++) {
+            const chunk = this._chunks[i];
+            offset += chunk.copy(out, offset, 0, chunk.length);
+        }
+        for (let i = this._bufferReadIndex; i < this._buffers.length; i++) {
+            const buf = this._buffers[i];
+            if (buf.isEOD) {
+                continue;
+            }
+            const view = buf.toUint8Array();
+            out.set(view, offset);
+            offset += view.length;
+        }
+        // Defensive: if internal counters drift, avoid returning trailing zeros.
+        return offset === out.length ? out : out.subarray(0, offset);
+    }
+    /**
+     * Check if stream is finished
+     */
+    get isFinished() {
+        return this._finished;
+    }
+    /**
+     * Check if stream is destroyed
+     */
+    get destroyed() {
+        return this._destroyed;
+    }
+}