@cj-tech-master/excelts 3.1.0 → 4.0.0

package/dist/esm/modules/stream/chunked-builder.js

@@ -0,0 +1,165 @@
+/**
+ * Chunked Builder (Browser Compatible)
+ *
+ * Browser-compatible version that uses Uint8Array instead of Buffer.
+ * This file provides the same API but works in browser environments.
+ */
+import { textEncoder } from "./shared.js";
+/**
+ * Efficient builder for accumulating and consolidating string chunks
+ * Browser-compatible version
+ */
+export class ChunkedBuilder {
+    constructor(options = {}) {
+        this._pieces = [];
+        this._chunks = [];
+        this._totalLength = 0;
+        this._chunkSize = options.chunkSize ?? 10000;
+    }
+    /**
+     * Add a piece to the builder
+     */
+    push(piece) {
+        this._pieces.push(piece);
+        this._totalLength += piece.length;
+        if (this._pieces.length >= this._chunkSize) {
+            this._consolidate();
+        }
+    }
+    /**
+     * Add multiple pieces
+     */
+    pushAll(pieces) {
+        const len = pieces.length;
+        for (let i = 0; i < len; i++) {
+            this._pieces.push(pieces[i]);
+            this._totalLength += pieces[i].length;
+        }
+        if (this._pieces.length >= this._chunkSize) {
+            this._consolidate();
+        }
+    }
+    /**
+     * Consolidate pieces into chunks
+     */
+    _consolidate() {
+        if (this._pieces.length > 0) {
+            this._chunks.push(this._pieces.join(""));
+            this._pieces = [];
+        }
+    }
+    /**
+     * Get current cursor position (useful for tracking changes)
+     */
+    get cursor() {
+        return this._chunks.length * this._chunkSize + this._pieces.length;
+    }
+    /**
+     * Get total piece/chunk count
+     */
+    get length() {
+        return this._pieces.length + this._chunks.length;
+    }
+    /**
+     * Get total string length (character count)
+     */
+    get stringLength() {
+        return this._totalLength;
+    }
+    /**
+     * Check if empty
+     */
+    get isEmpty() {
+        return this._pieces.length === 0 && this._chunks.length === 0;
+    }
+    /**
+     * Clear all content
+     */
+    clear() {
+        this._pieces = [];
+        this._chunks = [];
+        this._totalLength = 0;
+    }
+    /**
+     * Build final string
+     */
+    toString() {
+        const chunksLen = this._chunks.length;
+        const piecesLen = this._pieces.length;
+        // Fast path: only pieces, no chunks
+        if (chunksLen === 0) {
+            if (piecesLen === 0) {
+                return "";
+            }
+            if (piecesLen === 1) {
+                return this._pieces[0];
+            }
+            return this._pieces.join("");
+        }
+        // Has chunks - consolidate and join
+        if (piecesLen > 0) {
+            this._chunks.push(this._pieces.join(""));
+            this._pieces = [];
+        }
+        if (this._chunks.length === 1) {
+            return this._chunks[0];
+        }
+        return this._chunks.join("");
+    }
+    /**
+     * Convert to Uint8Array (browser-compatible)
+     */
+    toUint8Array() {
+        return textEncoder.encode(this.toString());
+    }
+}
+/**
+ * Chunked builder with rollback/commit support
+ * Browser-compatible version
+ */
+export class TransactionalChunkedBuilder extends ChunkedBuilder {
+    constructor() {
+        super(...arguments);
+        this._snapshots = [];
+    }
+    /**
+     * Create a rollback point
+     */
+    snapshot() {
+        const snap = {
+            piecesLength: this._pieces.length,
+            chunksLength: this._chunks.length,
+            totalLength: this._totalLength
+        };
+        this._snapshots.push(snap);
+        return snap;
+    }
+    /**
+     * Commit the current snapshot (remove rollback point)
+     */
+    commit() {
+        this._snapshots.pop();
+    }
+    /**
+     * Rollback to the last snapshot
+     */
+    rollback() {
+        const snap = this._snapshots.pop();
+        if (!snap) {
+            throw new Error("No snapshot to rollback to");
+        }
+        if (this._pieces.length > snap.piecesLength) {
+            this._pieces.length = snap.piecesLength;
+        }
+        if (this._chunks.length > snap.chunksLength) {
+            this._chunks.length = snap.chunksLength;
+        }
+        this._totalLength = snap.totalLength;
+    }
+    /**
+     * Check if there are active snapshots
+     */
+    get hasSnapshots() {
+        return this._snapshots.length > 0;
+    }
+}

package/dist/esm/modules/stream/event-emitter.js

@@ -0,0 +1,239 @@
+/**
+ * Event Emitter
+ *
+ * Browser-compatible EventEmitter with a Node.js-like API surface.
+ * Kept lightweight and allocation-lean for hot paths.
+ */
+const isListenerList = (value) => Array.isArray(value);
+export class EventEmitter {
+    constructor() {
+        // Brand for ExcelTS browser stream objects.
+        // Use a string key (not a Symbol) so it still works if the bundle ends up
+        // containing multiple copies of this module.
+        this.__excelts_stream = true;
+        this._listeners = new Map();
+        this._maxListeners = EventEmitter.defaultMaxListeners;
+    }
+    addListener(event, listener) {
+        return this.on(event, listener);
+    }
+    _listenerCount(value) {
+        if (!value) {
+            return 0;
+        }
+        return isListenerList(value) ? value.length : 1;
+    }
+    _hasListeners(event) {
+        return this._listenerCount(this._listeners.get(event)) > 0;
+    }
+    on(event, listener) {
+        const existing = this._listeners.get(event);
+        // Warn if exceeding max listeners (skip check if maxListeners is 0 = unlimited)
+        if (this._maxListeners > 0) {
+            const count = this._listenerCount(existing);
+            if (count >= this._maxListeners) {
+                // Avoid hard dependency on console for bundle/minified builds
+                console?.warn?.(`MaxListenersExceededWarning: Possible EventEmitter memory leak detected. ` +
+                    `${count + 1} ${String(event)} listeners added. ` +
+                    `Use emitter.setMaxListeners() to increase limit`);
+            }
+        }
+        if (!existing) {
+            this._listeners.set(event, listener);
+        }
+        else if (isListenerList(existing)) {
+            existing.push(listener);
+        }
+        else {
+            this._listeners.set(event, [existing, listener]);
+        }
+        // Node emits 'newListener' only if someone is listening to it.
+        if (event !== "newListener" && this._hasListeners("newListener")) {
+            this.emit("newListener", event, listener);
+        }
+        return this;
+    }
+    prependListener(event, listener) {
+        const existing = this._listeners.get(event);
+        if (!existing) {
+            this._listeners.set(event, listener);
+        }
+        else if (isListenerList(existing)) {
+            existing.unshift(listener);
+        }
+        else {
+            this._listeners.set(event, [listener, existing]);
+        }
+        if (event !== "newListener" && this._hasListeners("newListener")) {
+            this.emit("newListener", event, listener);
+        }
+        return this;
+    }
+    once(event, listener) {
+        const onceWrapper = (...args) => {
+            this.off(event, onceWrapper);
+            listener.apply(this, args);
+        };
+        onceWrapper.listener = listener;
+        return this.on(event, onceWrapper);
+    }
+    prependOnceListener(event, listener) {
+        const onceWrapper = (...args) => {
+            this.off(event, onceWrapper);
+            listener.apply(this, args);
+        };
+        onceWrapper.listener = listener;
+        return this.prependListener(event, onceWrapper);
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    off(event, listener) {
+        const existing = this._listeners.get(event);
+        if (!existing) {
+            return this;
+        }
+        if (!isListenerList(existing)) {
+            if (existing === listener || existing.listener === listener) {
+                this._listeners.delete(event);
+                if (event !== "removeListener" && this._hasListeners("removeListener")) {
+                    this.emit("removeListener", event, listener);
+                }
+            }
+            return this;
+        }
+        const listeners = existing;
+        if (listeners.length === 0) {
+            this._listeners.delete(event);
+            return this;
+        }
+        // Fast path: direct match
+        const directIdx = listeners.indexOf(listener);
+        if (directIdx !== -1) {
+            listeners.splice(directIdx, 1);
+        }
+        else {
+            // Slow path: check for once wrapper
+            for (let i = 0, len = listeners.length; i < len; i++) {
+                if (listeners[i].listener === listener) {
+                    listeners.splice(i, 1);
+                    break;
+                }
+            }
+        }
+        if (listeners.length === 0) {
+            this._listeners.delete(event);
+        }
+        else if (listeners.length === 1) {
+            this._listeners.set(event, listeners[0]);
+        }
+        if (event !== "removeListener" && this._hasListeners("removeListener")) {
+            this.emit("removeListener", event, listener);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const existing = this._listeners.get(event);
+        if (!existing) {
+            return false;
+        }
+        if (!isListenerList(existing)) {
+            try {
+                existing.apply(this, args);
+            }
+            catch (err) {
+                if (event !== "error") {
+                    this.emit("error", err);
+                }
+            }
+            return true;
+        }
+        const listeners = existing;
+        const len = listeners.length;
+        if (len === 0) {
+            return false;
+        }
+        if (len === 1) {
+            try {
+                listeners[0].apply(this, args);
+            }
+            catch (err) {
+                if (event !== "error") {
+                    this.emit("error", err);
+                }
+            }
+            return true;
+        }
+        if (len === 2) {
+            const l0 = listeners[0];
+            const l1 = listeners[1];
+            try {
+                l0.apply(this, args);
+            }
+            catch (err) {
+                if (event !== "error") {
+                    this.emit("error", err);
+                }
+            }
+            try {
+                l1.apply(this, args);
+            }
+            catch (err) {
+                if (event !== "error") {
+                    this.emit("error", err);
+                }
+            }
+            return true;
+        }
+        // Snapshot to allow removal during emit
+        const snapshot = listeners.slice();
+        for (let i = 0; i < snapshot.length; i++) {
+            try {
+                snapshot[i].apply(this, args);
+            }
+            catch (err) {
+                if (event !== "error") {
+                    this.emit("error", err);
+                }
+            }
+        }
+        return true;
+    }
+    removeAllListeners(event) {
+        if (event !== undefined) {
+            this._listeners.delete(event);
+        }
+        else {
+            this._listeners.clear();
+        }
+        return this;
+    }
+    listenerCount(event) {
+        return this._listenerCount(this._listeners.get(event));
+    }
+    listeners(event) {
+        const value = this._listeners.get(event);
+        if (!value) {
+            return [];
+        }
+        return isListenerList(value) ? value.slice() : [value];
+    }
+    rawListeners(event) {
+        const value = this._listeners.get(event);
+        if (!value) {
+            return [];
+        }
+        return isListenerList(value) ? value.slice() : [value];
+    }
+    eventNames() {
+        return [...this._listeners.keys()];
+    }
+    setMaxListeners(n) {
+        this._maxListeners = n;
+        return this;
+    }
+    getMaxListeners() {
+        return this._maxListeners;
+    }
+}
+EventEmitter.defaultMaxListeners = 10;

package/dist/esm/modules/stream/index.browser.js

@@ -0,0 +1,25 @@
+/**
+ * Stream Module (browser type surface)
+ *
+ * Mirrors [src/modules/stream/index.ts] but explicitly re-exports from
+ * ./streams.browser so we can enforce index export-surface parity.
+ */
+// =============================================================================
+// Native Stream Classes and Functions (browser)
+// =============================================================================
+import { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "./streams.browser.js";
+export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, Writeable, consumers, promises };
+import { EventEmitter } from "./event-emitter.js";
+export { EventEmitter };
+// =============================================================================
+// ChunkedBuilder (platform-independent)
+// =============================================================================
+import { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
+export { ChunkedBuilder, TransactionalChunkedBuilder };
+// =============================================================================
+// Utility Functions (platform-independent)
+// =============================================================================
+import { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
+export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays };
+import { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";
+export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter };

package/dist/esm/modules/stream/index.js

@@ -0,0 +1,52 @@
+/**
+ * Stream Module
+ *
+ * Native stream implementations for Node.js and Browser.
+ *
+ * - Node.js: Uses native `stream` module (Readable, Writable, Transform, Duplex, PassThrough)
+ * - Browser: Uses Web Streams API (ReadableStream, WritableStream, TransformStream)
+ *
+ * Both implementations provide the same API for cross-platform compatibility.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   Readable,
+ *   Writable,
+ *   Transform,
+ *   Duplex,
+ *   PassThrough,
+ *   pipeline,
+ *   createTransform,
+ *   streamToUint8Array
+ * } from './modules/stream.js';
+ *
+ * // Create a transform stream
+ * const uppercase = createTransform<Uint8Array, Uint8Array>(chunk => {
+ *   const text = new TextDecoder().decode(chunk);
+ *   return new TextEncoder().encode(text.toUpperCase());
+ * });
+ *
+ * // Use pipeline for clean stream composition
+ * await pipeline(readable, uppercase, writable);
+ * ```
+ */
+// =============================================================================
+// Native Stream Classes and Functions (platform-specific)
+// =============================================================================
+import { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "./streams.js";
+export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, Writeable, consumers, promises };
+import { EventEmitter } from "./event-emitter.js";
+export { EventEmitter };
+// =============================================================================
+// ChunkedBuilder (platform-independent)
+// =============================================================================
+import { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
+export { ChunkedBuilder, TransactionalChunkedBuilder };
+// =============================================================================
+// Utility Functions (platform-independent)
+// =============================================================================
+import { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
+export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays };
+import { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";
+export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter };

package/dist/esm/modules/stream/pull-stream.js

@@ -0,0 +1,204 @@
+/**
+ * Pull Stream
+ *
+ * A stream that allows pulling data from internal buffer with pattern matching.
+ * Works identically in both browser and Node.js environments.
+ */
+import { EventEmitter } from "./event-emitter.js";
+import { concatUint8Arrays } from "./shared.js";
+/**
+ * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
+ */
+export class PullStream extends EventEmitter {
+    constructor(_options = {}) {
+        super();
+        // Use chunked buffer storage to avoid repeated concat
+        this._bufferChunks = [];
+        this._totalLength = 0;
+        this.finished = false;
+        this._destroyed = false;
+    }
+    // Consolidate chunks into single buffer when needed
+    get buffer() {
+        const len = this._bufferChunks.length;
+        if (len === 0) {
+            return new Uint8Array(0);
+        }
+        if (len === 1) {
+            return this._bufferChunks[0];
+        }
+        // Consolidate multiple chunks
+        const buf = concatUint8Arrays(this._bufferChunks);
+        this._bufferChunks = [buf];
+        return buf;
+    }
+    set buffer(buf) {
+        this._bufferChunks = buf.length > 0 ? [buf] : [];
+        this._totalLength = buf.length;
+    }
+    /**
+     * Write data to the stream
+     */
+    write(chunk) {
+        if (this._destroyed) {
+            this.emit("error", new Error("Cannot write to destroyed stream"));
+            return false;
+        }
+        this._bufferChunks.push(chunk);
+        this._totalLength += chunk.length;
+        this.emit("chunk");
+        return true;
+    }
+    /**
+     * Signal end of input
+     */
+    end(chunk) {
+        if (chunk !== undefined) {
+            this.write(chunk);
+        }
+        this.finished = true;
+        this.emit("chunk", false);
+        this.emit("finish");
+        this.emit("end");
+    }
+    /**
+     * Destroy the stream
+     */
+    destroy(error) {
+        if (this._destroyed) {
+            return;
+        }
+        this._destroyed = true;
+        this._bufferChunks = [];
+        this._totalLength = 0;
+        if (error) {
+            this.emit("error", error);
+        }
+        this.emit("close");
+    }
+    pull(sizeOrPattern, includePattern) {
+        if (typeof sizeOrPattern === "number") {
+            return this._pullSize(sizeOrPattern);
+        }
+        return this._pullPattern(sizeOrPattern, includePattern ?? false);
+    }
+    /**
+     * Pull until pattern is found (alias for pull(pattern, includePattern))
+     */
+    pullUntil(pattern, includePattern) {
+        return this._pullPattern(pattern, includePattern ?? false);
+    }
+    _pullSize(size) {
+        return new Promise((resolve, reject) => {
+            const tryPull = () => {
+                if (this._destroyed) {
+                    reject(new Error("Stream destroyed"));
+                    return;
+                }
+                // Use _totalLength for fast check before consolidating
+                if (this._totalLength >= size) {
+                    const buf = this.buffer;
+                    const result = buf.subarray(0, size);
+                    this.buffer = buf.subarray(size);
+                    resolve(result);
+                    return;
+                }
+                if (this.finished) {
+                    // Return whatever we have
+                    const result = this.buffer;
+                    this._bufferChunks = [];
+                    this._totalLength = 0;
+                    resolve(result);
+                    return;
+                }
+                // Wait for more data
+                this.once("chunk", tryPull);
+            };
+            tryPull();
+        });
+    }
+    _pullPattern(pattern, includePattern) {
+        return new Promise((resolve, reject) => {
+            const tryPull = () => {
+                if (this._destroyed) {
+                    reject(new Error("Stream destroyed"));
+                    return;
+                }
+                const buf = this.buffer;
+                const matchIndex = this._indexOf(buf, pattern);
+                if (matchIndex !== -1) {
+                    this._match = matchIndex;
+                    const endIndex = includePattern ? matchIndex + pattern.length : matchIndex;
+                    const result = buf.subarray(0, endIndex);
+                    this.buffer = buf.subarray(includePattern ? endIndex : matchIndex + pattern.length);
+                    resolve(result);
+                    return;
+                }
+                if (this.finished) {
+                    // Pattern not found, return everything
+                    const result = buf;
+                    this._bufferChunks = [];
+                    this._totalLength = 0;
+                    resolve(result);
+                    return;
+                }
+                // Wait for more data
+                this.once("chunk", tryPull);
+            };
+            tryPull();
+        });
+    }
+    /**
+     * Get the match position from last pattern match
+     */
+    get matchPosition() {
+        return this._match;
+    }
+    /**
+     * Get remaining buffer length
+     */
+    get length() {
+        return this._totalLength;
+    }
+    /**
+     * Check if stream is finished
+     */
+    get isFinished() {
+        return this.finished;
+    }
+    /**
+     * Check if stream is destroyed
+     */
+    get destroyed() {
+        return this._destroyed;
+    }
+    /**
+     * Find pattern in Uint8Array (like Buffer.indexOf)
+     */
+    _indexOf(haystack, needle, start = 0) {
+        const needleLen = needle.length;
+        if (needleLen === 0) {
+            return start;
+        }
+        const haystackLen = haystack.length;
+        if (needleLen > haystackLen) {
+            return -1;
+        }
+        const first = needle[0];
+        const last = haystackLen - needleLen;
+        outer: for (let i = start; i <= last; i++) {
+            // Quick check first byte
+            if (haystack[i] !== first) {
+                continue;
+            }
+            // Check rest of pattern
+            for (let j = 1; j < needleLen; j++) {
+                if (haystack[i + j] !== needle[j]) {
+                    continue outer;
+                }
+            }
+            return i;
+        }
+        return -1;
+    }
+}