@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102043356.6791d4e

package/dist/esm/utils/stream-buf.browser.js

@@ -1,352 +0,0 @@
-import { StringBuf } from "./string-buf.js";
-// =============================================================================
-// Data chunks - encapsulating incoming data
-class StringChunk {
-    constructor(data, encoding) {
-        this._data = data;
-        this._encoding = encoding;
-    }
-    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);
-    }
-    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 - Browser version without Node.js stream dependency
-// A simple buffer manager that mimics stream behavior for xlsx writing
-class StreamBuf {
-    constructor(options) {
-        options = options || {};
-        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.events = new Map();
-    }
-    // Event emitter methods
-    on(event, callback) {
-        const callbacks = this.events.get(event) || [];
-        callbacks.push(callback);
-        this.events.set(event, callbacks);
-        return this;
-    }
-    once(event, callback) {
-        const onceCallback = (...args) => {
-            this.off(event, onceCallback);
-            callback(...args);
-        };
-        return this.on(event, onceCallback);
-    }
-    off(event, callback) {
-        const callbacks = this.events.get(event) || [];
-        const index = callbacks.indexOf(callback);
-        if (index !== -1) {
-            callbacks.splice(index, 1);
-        }
-        return this;
-    }
-    emit(event, ...args) {
-        const callbacks = this.events.get(event) || [];
-        callbacks.forEach(cb => cb(...args));
-        return callbacks.length > 0;
-    }
-    removeListener(event, callback) {
-        return this.off(event, callback);
-    }
-    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 _pipe(chunk) {
-        const write = (pipe) => {
-            return new Promise(resolve => {
-                pipe.write(chunk.toBuffer(), () => {
-                    resolve();
-                });
-            });
-        };
-        await Promise.all(this.pipes.map(write));
-    }
-    _writeToBuffers(chunk) {
-        let inPos = 0;
-        const inLen = chunk.length;
-        while (inPos < inLen) {
-            const buffer = this._getWritableBuffer();
-            inPos += buffer.write(chunk, inPos, inLen - inPos);
-        }
-    }
-    async write(data, encoding, callback) {
-        const nop = () => { };
-        if (encoding instanceof Function) {
-            callback = encoding;
-            encoding = "utf8";
-        }
-        callback = callback || nop;
-        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" || data instanceof String) {
-            chunk = new StringChunk(String(data), encoding);
-        }
-        else {
-            throw new Error("Chunk must be one of type String, Uint8Array, ArrayBuffer or StringBuf.");
-        }
-        if (this.pipes.length) {
-            if (this.batch) {
-                this._writeToBuffers(chunk);
-                while (!this.corked && this.buffers.length > 1) {
-                    await this._pipe(new BufferChunk(this.buffers.shift().toBuffer()));
-                }
-            }
-            else if (!this.corked) {
-                await this._pipe(chunk);
-                callback();
-            }
-            else {
-                this._writeToBuffers(chunk);
-                queueMicrotask(() => callback());
-            }
-        }
-        else {
-            if (!this.paused) {
-                this.emit("data", chunk.toBuffer());
-            }
-            this._writeToBuffers(chunk);
-            this.emit("readable");
-        }
-        return true;
-    }
-    cork() {
-        this.corked = true;
-    }
-    _flush() {
-        if (this.pipes.length) {
-            while (this.buffers.length) {
-                this._pipe(new BufferChunk(this.buffers.shift().toBuffer()));
-            }
-        }
-    }
-    uncork() {
-        this.corked = false;
-        this._flush();
-    }
-    end(chunk, encoding, callback) {
-        const writeComplete = (error) => {
-            if (error) {
-                callback?.(error);
-            }
-            else {
-                this._flush();
-                this.pipes.forEach((pipe) => {
-                    pipe.end();
-                });
-                this.emit("finish");
-            }
-        };
-        if (chunk) {
-            this.write(chunk, encoding, writeComplete);
-        }
-        else {
-            writeComplete();
-        }
-    }
-    read(size) {
-        let buffers;
-        if (size) {
-            buffers = [];
-            while (size && this.buffers.length && !this.buffers[0].eod) {
-                const first = this.buffers[0];
-                const buffer = first.read(size);
-                if (buffer) {
-                    size -= buffer.length;
-                    buffers.push(buffer);
-                }
-                if (first.eod && first.full) {
-                    this.buffers.shift();
-                }
-            }
-            return concatUint8Arrays(buffers);
-        }
-        buffers = this.buffers.map(buf => buf.toBuffer()).filter(Boolean);
-        this.buffers = [];
-        return concatUint8Arrays(buffers);
-    }
-    setEncoding(encoding) {
-        this.encoding = encoding;
-    }
-    pause() {
-        this.paused = true;
-    }
-    resume() {
-        this.paused = false;
-    }
-    isPaused() {
-        return this.paused;
-    }
-    pipe(destination) {
-        this.pipes.push(destination);
-        if (!this.paused && this.buffers.length) {
-            this.end();
-        }
-        return destination;
-    }
-    unpipe(destination) {
-        this.pipes = this.pipes.filter((pipe) => pipe !== destination);
-    }
-    unshift() {
-        throw new Error("Not Implemented");
-    }
-    wrap() {
-        throw new Error("Not Implemented");
-    }
-    push(chunk) {
-        if (chunk !== null) {
-            this.write(chunk);
-        }
-        return true;
-    }
-}
-// Helper function to concatenate Uint8Arrays
-function concatUint8Arrays(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/esm/utils/stream-buf.js

@@ -1,344 +0,0 @@
-import { Duplex } from "stream";
-import { inherits, nop } from "./utils.js";
-import { StringBuf } from "./string-buf.js";
-// =============================================================================
-// data chunks - encapsulating incoming data
-class StringChunk {
-    constructor(data, encoding) {
-        this._data = data;
-        this._encoding = encoding;
-    }
-    get length() {
-        return this.toBuffer().length;
-    }
-    // copy to target buffer
-    copy(target, targetOffset, offset, length) {
-        return this.toBuffer().copy(target, targetOffset, offset, length);
-    }
-    toBuffer() {
-        if (!this._buffer) {
-            this._buffer = Buffer.from(this._data, this._encoding);
-        }
-        return this._buffer;
-    }
-}
-class StringBufChunk {
-    constructor(data) {
-        this._data = data;
-    }
-    get length() {
-        return this._data.length;
-    }
-    // copy to target buffer
-    copy(target, targetOffset, offset, length) {
-        return this._data._buf.copy(target, targetOffset, offset, length);
-    }
-    toBuffer() {
-        return this._data.toBuffer();
-    }
-}
-class BufferChunk {
-    constructor(data) {
-        this._data = data;
-    }
-    get length() {
-        return this._data.length;
-    }
-    // copy to target buffer
-    copy(target, targetOffset, offset, length) {
-        this._data.copy(target, targetOffset, offset, length);
-    }
-    toBuffer() {
-        return this._data;
-    }
-}
-// =============================================================================
-// ReadWriteBuf - a single buffer supporting simple read-write
-class ReadWriteBuf {
-    constructor(size) {
-        this.size = size;
-        // the buffer
-        this.buffer = Buffer.alloc(size);
-        // read index
-        this.iRead = 0;
-        // write index
-        this.iWrite = 0;
-    }
-    toBuffer() {
-        if (this.iRead === 0 && this.iWrite === this.size) {
-            return this.buffer;
-        }
-        const buf = Buffer.alloc(this.iWrite - this.iRead);
-        this.buffer.copy(buf, 0, this.iRead, this.iWrite);
-        return buf;
-    }
-    get length() {
-        return this.iWrite - this.iRead;
-    }
-    get eod() {
-        return this.iRead === this.iWrite;
-    }
-    get full() {
-        return this.iWrite === this.size;
-    }
-    read(size) {
-        let buf;
-        // read size bytes from buffer and return buffer
-        if (size === 0) {
-            // special case - return null if no data requested
-            return null;
-        }
-        if (size === undefined || size >= this.length) {
-            // if no size specified or size is at least what we have then return all of the bytes
-            buf = this.toBuffer();
-            this.iRead = this.iWrite;
-            return buf;
-        }
-        // otherwise return a chunk
-        buf = Buffer.alloc(size);
-        this.buffer.copy(buf, 0, this.iRead, size);
-        this.iRead += size;
-        return buf;
-    }
-    write(chunk, offset, length) {
-        // write as many bytes from data from optional source offset
-        // and return number of bytes written
-        const size = Math.min(length, this.size - this.iWrite);
-        chunk.copy(this.buffer, this.iWrite, offset, offset + size);
-        this.iWrite += size;
-        return size;
-    }
-}
-// =============================================================================
-// StreamBuf - a multi-purpose read-write stream
-//  As MemBuf - write as much data as you like. Then call toBuffer() to consolidate
-//  As StreamHub - pipe to multiple writables
-//  As readable stream - feed data into the writable part and have some other code read from it.
-// Note: Not sure why but StreamBuf does not like JS "class" sugar. It fails the
-// integration tests
-const StreamBuf = function (options) {
-    if (!(this instanceof StreamBuf)) {
-        return new StreamBuf(options);
-    }
-    Duplex.call(this, options);
-    options = options || {};
-    this.bufSize = options.bufSize || 1024 * 1024;
-    this.buffers = [];
-    // batch mode fills a buffer completely before passing the data on
-    // to pipes or 'readable' event listeners
-    this.batch = options.batch || false;
-    this.corked = false;
-    // where in the current writable buffer we're up to
-    this.inPos = 0;
-    // where in the current readable buffer we've read up to
-    this.outPos = 0;
-    // consuming pipe streams go here
-    this.pipes = [];
-    // controls emit('data')
-    this.paused = false;
-    this.encoding = null;
-};
-inherits(StreamBuf, Duplex, {
-    toBuffer() {
-        switch (this.buffers.length) {
-            case 0:
-                return null;
-            case 1:
-                return this.buffers[0].toBuffer();
-            default:
-                return Buffer.concat(this.buffers.map((rwBuf) => rwBuf.toBuffer()));
-        }
-    },
-    // writable
-    // event drain - if write returns false (which it won't), indicates when safe to write again.
-    // finish - end() has been called
-    // pipe(src) - pipe() has been called on readable
-    // unpipe(src) - unpipe() has been called on readable
-    // error - duh
-    _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 _pipe(chunk) {
-        const write = function (pipe) {
-            return new Promise(resolve => {
-                pipe.write(chunk.toBuffer(), () => {
-                    resolve();
-                });
-            });
-        };
-        await Promise.all(this.pipes.map(write));
-    },
-    _writeToBuffers(chunk) {
-        let inPos = 0;
-        const inLen = chunk.length;
-        while (inPos < inLen) {
-            // find writable buffer
-            const buffer = this._getWritableBuffer();
-            // write some data
-            inPos += buffer.write(chunk, inPos, inLen - inPos);
-        }
-    },
-    async write(data, encoding, callback) {
-        if (encoding instanceof Function) {
-            callback = encoding;
-            encoding = "utf8";
-        }
-        callback = callback || nop;
-        // encapsulate data into a chunk
-        let chunk;
-        // Use constructor name check for better ES6 module compatibility
-        if (data instanceof StringBuf || (data && data.constructor?.name === "StringBuf")) {
-            chunk = new StringBufChunk(data);
-        }
-        else if (Buffer.isBuffer(data)) {
-            // Use Buffer.isBuffer() instead of instanceof for cross-realm compatibility
-            // (e.g., Web Workers where Buffer polyfill instances may differ)
-            chunk = new BufferChunk(data);
-        }
-        else if (ArrayBuffer.isView(data)) {
-            // Handle typed arrays (Uint8Array, Int8Array, etc.) - cross-realm safe
-            chunk = new BufferChunk(Buffer.from(data.buffer, data.byteOffset, data.byteLength));
-        }
-        else if (data instanceof ArrayBuffer) {
-            // Handle ArrayBuffer - convert to Buffer
-            chunk = new BufferChunk(Buffer.from(data));
-        }
-        else if (typeof data === "string" || data instanceof String) {
-            chunk = new StringChunk(String(data), encoding);
-        }
-        else {
-            throw new Error("Chunk must be one of type String, Buffer, Uint8Array, ArrayBuffer or StringBuf.");
-        }
-        // now, do something with the chunk
-        if (this.pipes.length) {
-            if (this.batch) {
-                this._writeToBuffers(chunk);
-                while (!this.corked && this.buffers.length > 1) {
-                    this._pipe(this.buffers.shift());
-                }
-            }
-            else if (!this.corked) {
-                await this._pipe(chunk);
-                callback();
-            }
-            else {
-                this._writeToBuffers(chunk);
-                // Use queueMicrotask for cross-platform compatibility (ES2020+)
-                queueMicrotask(() => callback());
-            }
-        }
-        else {
-            if (!this.paused) {
-                this.emit("data", chunk.toBuffer());
-            }
-            this._writeToBuffers(chunk);
-            this.emit("readable");
-        }
-        return true;
-    },
-    cork() {
-        this.corked = true;
-    },
-    _flush() {
-        // if we have comsumers...
-        if (this.pipes.length) {
-            // and there's stuff not written
-            while (this.buffers.length) {
-                this._pipe(this.buffers.shift());
-            }
-        }
-    },
-    uncork() {
-        this.corked = false;
-        this._flush();
-    },
-    end(chunk, encoding, callback) {
-        const writeComplete = (error) => {
-            if (error) {
-                callback(error);
-            }
-            else {
-                this._flush();
-                this.pipes.forEach((pipe) => {
-                    pipe.end();
-                });
-                this.emit("finish");
-            }
-        };
-        if (chunk) {
-            this.write(chunk, encoding, writeComplete);
-        }
-        else {
-            writeComplete();
-        }
-    },
-    // readable
-    // event readable - some data is now available
-    // event data - switch to flowing mode - feeds chunks to handler
-    // event end - no more data
-    // event close - optional, indicates upstream close
-    // event error - duh
-    read(size) {
-        let buffers;
-        // read min(buffer, size || infinity)
-        if (size) {
-            buffers = [];
-            while (size && this.buffers.length && !this.buffers[0].eod) {
-                const first = this.buffers[0];
-                const buffer = first.read(size);
-                size -= buffer.length;
-                buffers.push(buffer);
-                if (first.eod && first.full) {
-                    this.buffers.shift();
-                }
-            }
-            return Buffer.concat(buffers);
-        }
-        buffers = this.buffers.map((buf) => buf.toBuffer()).filter(Boolean);
-        this.buffers = [];
-        return Buffer.concat(buffers);
-    },
-    setEncoding(encoding) {
-        // causes stream.read or stream.on('data) to return strings of encoding instead of Buffer objects
-        this.encoding = encoding;
-    },
-    pause() {
-        this.paused = true;
-    },
-    resume() {
-        this.paused = false;
-    },
-    isPaused() {
-        return !!this.paused;
-    },
-    pipe(destination) {
-        // add destination to pipe list & write current buffer
-        this.pipes.push(destination);
-        if (!this.paused && this.buffers.length) {
-            this.end();
-        }
-        return destination;
-    },
-    unpipe(destination) {
-        // remove destination from pipe list
-        this.pipes = this.pipes.filter((pipe) => pipe !== destination);
-    },
-    unshift() {
-        // some numpty has read some data that's not for them and they want to put it back!
-        // Might implement this some day
-        throw new Error("Not Implemented");
-    },
-    wrap() {
-        // not implemented
-        throw new Error("Not Implemented");
-    }
-});
-export { StreamBuf };