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

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

@@ -1,245 +0,0 @@
-"use strict";
-/**
- * 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)
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.XLSX = void 0;
-const fs_1 = __importDefault(require("fs"));
-const utils_1 = require("@utils/utils");
-const xlsx_browser_1 = require("@excel/xlsx/xlsx.browser");
-const _archive_1 = require("@archive");
-const _stream_1 = require("@stream");
-class XLSX extends xlsx_browser_1.XLSX {
-    constructor(workbook) {
-        super(workbook);
-        // Provide file reading capability for addMedia
-        this.readFileAsync = (filename) => fs_1.default.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 _archive_1.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 _stream_1.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 = (0, _stream_1.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 (0, utils_1.fileExists)(filename))) {
-            throw new Error(`File not found: ${filename}`);
-        }
-        const stream = fs_1.default.createReadStream(filename);
-        return this.read(stream, options);
-    }
-    writeFile(filename, options) {
-        const stream = fs_1.default.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);
-            });
-        });
-    }
-}
-exports.XLSX = XLSX;

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

@@ -1,164 +0,0 @@
-"use strict";
-/**
- * Base Transform Stream
- *
- * Provides a base class for Transform streams.
- * Works identically in both browser and Node.js environments.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTransform = void 0;
-const event_emitter_1 = require("@stream/event-emitter");
-/**
- * Browser-compatible Base Transform stream
- */
-class BaseTransform extends event_emitter_1.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;
-    }
-}
-exports.BaseTransform = BaseTransform;

package/dist/cjs/modules/stream/buffered-stream.js

@@ -1,283 +0,0 @@
-"use strict";
-/**
- * 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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BufferedStream = exports.BufferChunk = exports.StringChunk = void 0;
-const event_emitter_1 = require("@stream/event-emitter");
-const shared_1 = require("@stream/shared");
-/**
- * String chunk implementation
- */
-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 = shared_1.textEncoder.encode(this._data);
-        }
-        return this._buffer;
-    }
-}
-exports.StringChunk = StringChunk;
-/**
- * Uint8Array chunk implementation
- */
-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;
-    }
-}
-exports.BufferChunk = BufferChunk;
-/**
- * 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
- */
-class BufferedStream extends event_emitter_1.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;
-    }
-}
-exports.BufferedStream = BufferedStream;