@cj-tech-master/excelts 4.0.0 → 4.0.1

package/dist/browser/modules/excel/utils/stream-buf.d.ts

@@ -0,0 +1,126 @@
+/**
+ * StreamBuf - Cross-Platform Multi-purpose Read-Write Stream
+ *
+ * A unified implementation that works in both Node.js and Browser environments
+ * using the cross-platform EventEmitter from modules/stream.
+ *
+ * Features:
+ * - As MemBuf: write data, then call toBuffer() to consolidate
+ * - As StreamHub: pipe to multiple writable streams
+ * - As readable stream: feed data into writable part and read from it
+ */
+import { EventEmitter } from "@stream";
+import { StringBuf } from "@excel/utils/string-buf";
+type TextEncoding = "utf-8" | "utf8" | BufferEncoding;
+interface StreamBufOptions {
+    bufSize?: number;
+    batch?: boolean;
+}
+/**
+ * StreamBuf is a multi-purpose read-write stream that works in both
+ * Node.js and Browser environments.
+ *
+ * It extends EventEmitter to provide stream-like events:
+ * - 'data': emitted when data is written (flowing mode)
+ * - 'readable': emitted when data is available to read
+ * - 'finish': emitted when end() is called
+ * - 'error': emitted on errors
+ * - 'drain': emitted when buffer drains (after pipe)
+ */
+declare class StreamBuf extends EventEmitter {
+    private bufSize;
+    private buffers;
+    private batch;
+    private corked;
+    private paused;
+    private encoding;
+    private pipes;
+    private _ended;
+    private _writableStream;
+    private _writableStreamWriter;
+    private _asyncWriteQueue;
+    constructor(options?: StreamBufOptions);
+    /**
+     * Returns true if the stream is writable (not ended)
+     * Required for compatibility with Node.js pipe()
+     */
+    get writable(): boolean;
+    /**
+     * Consolidate all buffers into a single Uint8Array
+     */
+    toBuffer(): Uint8Array | null;
+    private _getWritableBuffer;
+    private _pipeChunk;
+    private _writeToBuffers;
+    /**
+     * Write data to the stream
+     */
+    write(data: Uint8Array | string | StringBuf | ArrayBuffer | ArrayBufferView, encoding?: TextEncoding | Function, callback?: Function): Promise<boolean>;
+    /**
+     * Cork the stream - buffer writes until uncork
+     */
+    cork(): void;
+    private _flush;
+    /**
+     * Uncork the stream - flush buffered writes
+     */
+    uncork(): void;
+    /**
+     * End the stream
+     */
+    end(chunk?: any, encoding?: TextEncoding, callback?: Function): void;
+    /**
+     * Read from the stream
+     */
+    read(size?: number): Uint8Array;
+    /**
+     * Read from the stream and return as string.
+     * Cross-platform compatible - works identically in Node.js and Browser.
+     */
+    readString(encoding?: TextEncoding): string;
+    /**
+     * Set encoding for string reads
+     */
+    setEncoding(encoding: string): void;
+    /**
+     * Pause the stream
+     */
+    pause(): void;
+    /**
+     * Resume the stream
+     */
+    resume(): void;
+    /**
+     * Check if stream is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Pipe to a writable stream
+     */
+    pipe<T extends {
+        write: Function;
+        end?: Function;
+    }>(destination: T): T;
+    /**
+     * Pipe to a native WritableStream (browser Streams API).
+     * This properly handles async writes and waits for completion before finish.
+     */
+    pipeTo(writableStream: WritableStream<Uint8Array>): void;
+    /**
+     * Remove a piped destination
+     */
+    unpipe(destination: any): void;
+    /**
+     * Put data back at the front (not implemented)
+     */
+    unshift(): void;
+    /**
+     * Wrap a stream (not implemented)
+     */
+    wrap(): void;
+    /**
+     * Push data to the stream (alias for write)
+     */
+    push(chunk: any): boolean;
+}
+export { StreamBuf };

package/dist/browser/modules/excel/utils/stream-buf.js

@@ -0,0 +1,452 @@
+/**
+ * StreamBuf - Cross-Platform Multi-purpose Read-Write Stream
+ *
+ * A unified implementation that works in both Node.js and Browser environments
+ * using the cross-platform EventEmitter from modules/stream.
+ *
+ * Features:
+ * - As MemBuf: write data, then call toBuffer() to consolidate
+ * - As StreamHub: pipe to multiple writable streams
+ * - As readable stream: feed data into writable part and read from it
+ */
+import { EventEmitter } from "../../stream/index.browser.js";
+import { StringBuf } from "./string-buf.js";
+class StringChunk {
+    constructor(data) {
+        this._data = data;
+    }
+    get length() {
+        return this.toBuffer().length;
+    }
+    copy(target, targetOffset, offset, length) {
+        const buf = this.toBuffer();
+        const bytesToCopy = Math.min(length, buf.length - offset);
+        target.set(buf.subarray(offset, offset + bytesToCopy), targetOffset);
+        return bytesToCopy;
+    }
+    toBuffer() {
+        if (!this._buffer) {
+            this._buffer = new TextEncoder().encode(this._data);
+        }
+        return this._buffer;
+    }
+}
+class StringBufChunk {
+    constructor(data) {
+        this._data = data;
+    }
+    get length() {
+        return this._data.length;
+    }
+    copy(target, targetOffset, offset, length) {
+        const buf = this.toBuffer();
+        const bytesToCopy = Math.min(length, buf.length - offset);
+        target.set(buf.subarray(offset, offset + bytesToCopy), targetOffset);
+        return bytesToCopy;
+    }
+    toBuffer() {
+        return this._data.toBuffer();
+    }
+}
+class BufferChunk {
+    constructor(data) {
+        this._data = data;
+    }
+    get length() {
+        return this._data.length;
+    }
+    copy(target, targetOffset, offset, length) {
+        const bytesToCopy = Math.min(length, this._data.length - offset);
+        target.set(this._data.subarray(offset, offset + bytesToCopy), targetOffset);
+        return bytesToCopy;
+    }
+    toBuffer() {
+        return this._data;
+    }
+}
+// =============================================================================
+// ReadWriteBuf - a single buffer supporting simple read-write
+// =============================================================================
+class ReadWriteBuf {
+    constructor(size) {
+        this.size = size;
+        this.buffer = new Uint8Array(size);
+        this.iRead = 0;
+        this.iWrite = 0;
+    }
+    toBuffer() {
+        if (this.iRead === 0 && this.iWrite === this.size) {
+            return this.buffer;
+        }
+        return this.buffer.slice(this.iRead, this.iWrite);
+    }
+    get length() {
+        return this.iWrite - this.iRead;
+    }
+    get eod() {
+        return this.iRead === this.iWrite;
+    }
+    get full() {
+        return this.iWrite === this.size;
+    }
+    read(size) {
+        if (size === 0) {
+            return null;
+        }
+        if (size === undefined || size >= this.length) {
+            const buf = this.toBuffer();
+            this.iRead = this.iWrite;
+            return buf;
+        }
+        const buf = this.buffer.slice(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, offset + size);
+        this.iWrite += size;
+        return size;
+    }
+}
+// =============================================================================
+// StreamBuf - Cross-Platform Implementation
+// =============================================================================
+/**
+ * StreamBuf is a multi-purpose read-write stream that works in both
+ * Node.js and Browser environments.
+ *
+ * It extends EventEmitter to provide stream-like events:
+ * - 'data': emitted when data is written (flowing mode)
+ * - 'readable': emitted when data is available to read
+ * - 'finish': emitted when end() is called
+ * - 'error': emitted on errors
+ * - 'drain': emitted when buffer drains (after pipe)
+ */
+class StreamBuf extends EventEmitter {
+    constructor(options) {
+        super();
+        // Native WritableStream support
+        this._writableStream = null;
+        this._writableStreamWriter = null;
+        this._asyncWriteQueue = Promise.resolve();
+        this.bufSize = options?.bufSize || 1024 * 1024;
+        this.buffers = [];
+        this.batch = options?.batch || false;
+        this.corked = false;
+        this.paused = false;
+        this.encoding = null;
+        this.pipes = [];
+        this._ended = false;
+    }
+    /**
+     * Returns true if the stream is writable (not ended)
+     * Required for compatibility with Node.js pipe()
+     */
+    get writable() {
+        return !this._ended;
+    }
+    /**
+     * Consolidate all buffers into a single Uint8Array
+     */
+    toBuffer() {
+        switch (this.buffers.length) {
+            case 0:
+                return null;
+            case 1:
+                return this.buffers[0].toBuffer();
+            default: {
+                const totalLength = this.buffers.reduce((acc, buf) => acc + buf.length, 0);
+                const result = new Uint8Array(totalLength);
+                let offset = 0;
+                for (const rwBuf of this.buffers) {
+                    const buf = rwBuf.toBuffer();
+                    result.set(buf, offset);
+                    offset += buf.length;
+                }
+                return result;
+            }
+        }
+    }
+    _getWritableBuffer() {
+        if (this.buffers.length) {
+            const last = this.buffers[this.buffers.length - 1];
+            if (!last.full) {
+                return last;
+            }
+        }
+        const buf = new ReadWriteBuf(this.bufSize);
+        this.buffers.push(buf);
+        return buf;
+    }
+    async _pipeChunk(chunk) {
+        const writePromises = this.pipes.map((pipe) => new Promise(resolve => {
+            pipe.write(chunk.toBuffer(), () => resolve());
+        }));
+        await Promise.all(writePromises);
+    }
+    _writeToBuffers(chunk) {
+        let inPos = 0;
+        const inLen = chunk.length;
+        while (inPos < inLen) {
+            const buffer = this._getWritableBuffer();
+            inPos += buffer.write(chunk, inPos, inLen - inPos);
+        }
+    }
+    /**
+     * Write data to the stream
+     */
+    async write(data, encoding, callback) {
+        const nop = () => { };
+        if (typeof encoding === "function") {
+            callback = encoding;
+        }
+        callback = callback || nop;
+        // Create chunk from data
+        let chunk;
+        if (data instanceof StringBuf || (data && data.constructor?.name === "StringBuf")) {
+            chunk = new StringBufChunk(data);
+        }
+        else if (data instanceof Uint8Array) {
+            chunk = new BufferChunk(data);
+        }
+        else if (ArrayBuffer.isView(data)) {
+            chunk = new BufferChunk(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+        }
+        else if (data instanceof ArrayBuffer) {
+            chunk = new BufferChunk(new Uint8Array(data));
+        }
+        else if (typeof data === "string") {
+            chunk = new StringChunk(data);
+        }
+        else {
+            throw new Error("Chunk must be one of type String, Uint8Array, ArrayBuffer or StringBuf.");
+        }
+        // Handle piping and buffering
+        if (this.pipes.length) {
+            if (this.batch) {
+                this._writeToBuffers(chunk);
+                while (!this.corked && this.buffers.length > 1) {
+                    const buf = this.buffers.shift();
+                    await this._pipeChunk(new BufferChunk(buf.toBuffer()));
+                }
+            }
+            else if (!this.corked) {
+                await this._pipeChunk(chunk);
+                callback();
+            }
+            else {
+                this._writeToBuffers(chunk);
+                queueMicrotask(() => callback());
+            }
+        }
+        else {
+            const chunkBuffer = chunk.toBuffer();
+            if (!this.paused) {
+                this.emit("data", chunkBuffer);
+            }
+            // Also write to native WritableStream if connected
+            if (this._writableStreamWriter) {
+                this._asyncWriteQueue = this._asyncWriteQueue.then(() => this._writableStreamWriter.write(chunkBuffer));
+            }
+            this._writeToBuffers(chunk);
+            this.emit("readable");
+        }
+        return true;
+    }
+    /**
+     * Cork the stream - buffer writes until uncork
+     */
+    cork() {
+        this.corked = true;
+    }
+    _flush() {
+        if (this.pipes.length) {
+            const flushAll = async () => {
+                while (this.buffers.length) {
+                    const buf = this.buffers.shift();
+                    await this._pipeChunk(new BufferChunk(buf.toBuffer()));
+                }
+            };
+            flushAll().catch(err => this.emit("error", err));
+        }
+    }
+    /**
+     * Uncork the stream - flush buffered writes
+     */
+    uncork() {
+        this.corked = false;
+        this._flush();
+    }
+    /**
+     * End the stream
+     */
+    end(chunk, encoding, callback) {
+        const writeComplete = (error) => {
+            if (error) {
+                callback?.(error);
+                return;
+            }
+            this._ended = true;
+            this._flush();
+            this.pipes.forEach((pipe) => {
+                if (typeof pipe.end === "function") {
+                    pipe.end();
+                }
+            });
+            // If we have a native WritableStream, wait for all async writes to complete
+            if (this._writableStreamWriter) {
+                this._asyncWriteQueue
+                    .then(() => this._writableStreamWriter.close())
+                    .then(() => {
+                    this.emit("finish");
+                })
+                    .catch(err => {
+                    this.emit("error", err);
+                });
+            }
+            else {
+                this.emit("finish");
+            }
+        };
+        if (chunk) {
+            this.write(chunk, encoding, writeComplete);
+        }
+        else {
+            writeComplete();
+        }
+    }
+    /**
+     * Read from the stream
+     */
+    read(size) {
+        if (size) {
+            const buffers = [];
+            let remaining = size;
+            while (remaining && this.buffers.length && !this.buffers[0].eod) {
+                const first = this.buffers[0];
+                const buffer = first.read(remaining);
+                if (buffer) {
+                    remaining -= buffer.length;
+                    buffers.push(buffer);
+                }
+                if (first.eod && first.full) {
+                    this.buffers.shift();
+                }
+            }
+            return concatUint8Arrays(buffers);
+        }
+        const buffers = this.buffers.map(buf => buf.toBuffer()).filter(Boolean);
+        this.buffers = [];
+        return concatUint8Arrays(buffers);
+    }
+    /**
+     * Read from the stream and return as string.
+     * Cross-platform compatible - works identically in Node.js and Browser.
+     */
+    readString(encoding) {
+        const enc = encoding || this.encoding || "utf-8";
+        const buf = this.read();
+        if (typeof Buffer !== "undefined" && buf instanceof Buffer) {
+            return buf.toString(enc);
+        }
+        return new TextDecoder(enc).decode(buf);
+    }
+    /**
+     * Set encoding for string reads
+     */
+    setEncoding(encoding) {
+        this.encoding = encoding;
+    }
+    /**
+     * Pause the stream
+     */
+    pause() {
+        this.paused = true;
+    }
+    /**
+     * Resume the stream
+     */
+    resume() {
+        this.paused = false;
+    }
+    /**
+     * Check if stream is paused
+     */
+    isPaused() {
+        return this.paused;
+    }
+    /**
+     * Pipe to a writable stream
+     */
+    pipe(destination) {
+        this.pipes.push(destination);
+        if (!this.paused && this.buffers.length) {
+            this.end();
+        }
+        return destination;
+    }
+    /**
+     * Pipe to a native WritableStream (browser Streams API).
+     * This properly handles async writes and waits for completion before finish.
+     */
+    pipeTo(writableStream) {
+        this._writableStream = writableStream;
+        this._writableStreamWriter = writableStream.getWriter();
+    }
+    /**
+     * Remove a piped destination
+     */
+    unpipe(destination) {
+        this.pipes = this.pipes.filter((pipe) => pipe !== destination);
+    }
+    /**
+     * Put data back at the front (not implemented)
+     */
+    unshift() {
+        throw new Error("Not Implemented");
+    }
+    /**
+     * Wrap a stream (not implemented)
+     */
+    wrap() {
+        throw new Error("Not Implemented");
+    }
+    /**
+     * Push data to the stream (alias for write)
+     */
+    push(chunk) {
+        if (chunk !== null) {
+            this.write(chunk);
+        }
+        return true;
+    }
+}
+// =============================================================================
+// Utility Functions
+// =============================================================================
+/**
+ * Concatenate multiple Uint8Arrays into one
+ * Returns Buffer in Node.js for better toString() compatibility
+ */
+function concatUint8Arrays(arrays) {
+    // In Node.js, use Buffer.concat for better compatibility (Buffer.toString() works)
+    if (typeof Buffer !== "undefined" && typeof Buffer.concat === "function") {
+        return Buffer.concat(arrays);
+    }
+    if (arrays.length === 0) {
+        return new Uint8Array(0);
+    }
+    if (arrays.length === 1) {
+        return arrays[0];
+    }
+    const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+export { StreamBuf };

package/dist/browser/modules/excel/utils/string-buf.d.ts

@@ -0,0 +1,29 @@
+/**
+ * StringBuf - Cross-Platform String Buffer
+ *
+ * A way to keep string memory operations to a minimum while building XML strings.
+ * Uses TextEncoder and Uint8Array for cross-platform compatibility (Node.js + Browser).
+ */
+interface StringBufOptions {
+    size?: number;
+    encoding?: string;
+}
+/**
+ * StringBuf - efficient string builder using Uint8Array
+ * Works identically in Node.js and Browser environments.
+ */
+declare class StringBuf {
+    private _buf;
+    private _inPos;
+    private _buffer;
+    constructor(options?: StringBufOptions);
+    get length(): number;
+    get capacity(): number;
+    get buffer(): Uint8Array;
+    toBuffer(): Uint8Array;
+    reset(position?: number): void;
+    private _grow;
+    addText(text: string): void;
+    addStringBuf(inBuf: StringBuf): void;
+}
+export { StringBuf };

package/dist/browser/modules/excel/utils/string-buf.js

@@ -0,0 +1,75 @@
+/**
+ * StringBuf - Cross-Platform String Buffer
+ *
+ * A way to keep string memory operations to a minimum while building XML strings.
+ * Uses TextEncoder and Uint8Array for cross-platform compatibility (Node.js + Browser).
+ */
+const encoder = new TextEncoder();
+/**
+ * StringBuf - efficient string builder using Uint8Array
+ * Works identically in Node.js and Browser environments.
+ */
+class StringBuf {
+    constructor(options) {
+        this._buf = new Uint8Array((options && options.size) || 16384);
+        // TextEncoder only supports UTF-8, so encoding option is ignored
+        this._inPos = 0;
+        this._buffer = undefined;
+    }
+    get length() {
+        return this._inPos;
+    }
+    get capacity() {
+        return this._buf.length;
+    }
+    get buffer() {
+        return this._buf;
+    }
+    toBuffer() {
+        // Return the current data as a single enclosing buffer
+        if (!this._buffer) {
+            this._buffer = this._buf.slice(0, this._inPos);
+        }
+        return this._buffer;
+    }
+    reset(position) {
+        position = position || 0;
+        this._buffer = undefined;
+        this._inPos = position;
+    }
+    _grow(min) {
+        let size = this._buf.length * 2;
+        while (size < min) {
+            size *= 2;
+        }
+        const buf = new Uint8Array(size);
+        buf.set(this._buf);
+        this._buf = buf;
+    }
+    addText(text) {
+        this._buffer = undefined;
+        // Encode string to UTF-8 bytes
+        const encoded = encoder.encode(text);
+        const minSpace = this._inPos + encoded.length;
+        // Grow preemptively: if remaining space < 4 bytes margin, double
+        // This matches original Buffer behavior where growth is triggered proactively
+        if (minSpace > this._buf.length - 4) {
+            this._grow(minSpace);
+        }
+        // Copy encoded bytes to buffer
+        this._buf.set(encoded, this._inPos);
+        this._inPos += encoded.length;
+    }
+    addStringBuf(inBuf) {
+        if (inBuf.length) {
+            this._buffer = undefined;
+            if (this.length + inBuf.length > this.capacity) {
+                this._grow(this.length + inBuf.length);
+            }
+            // Copy bytes from input buffer
+            this._buf.set(inBuf._buf.subarray(0, inBuf.length), this._inPos);
+            this._inPos += inBuf.length;
+        }
+    }
+}
+export { StringBuf };

package/dist/browser/modules/excel/utils/under-dash.d.ts

@@ -0,0 +1,7 @@
+export declare function isEqual(a: any, b: any): boolean;
+export declare function escapeHtml(html: string): string;
+export declare function isUndefined(val: any): val is undefined;
+export declare function isObject(val: any): val is Record<string, any>;
+export declare function deepMerge<T = any>(...args: any[]): T;
+export declare function cloneDeep(obj: any, preserveUndefined?: boolean): any;
+export declare function get<T = any>(obj: any, path: string, defaultValue?: T): T;