@cj-tech-master/excelts 4.0.0 → 4.0.1

package/dist/browser/modules/archive/streaming-compress.base.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared types for true streaming compression.
+ *
+ * Kept in a dedicated base module so Node.js and browser implementations
+ * don't depend on each other.
+ */
+export interface StreamCompressOptions {
+    level?: number;
+}
+export type StreamCallback = (err?: Error | null) => void;
+/**
+ * Minimal cross-platform streaming codec surface.
+ *
+ * Both Node.js (zlib / stream.Transform) and browser implementations
+ * support this subset.
+ */
+export interface StreamingCodec {
+    on(event: "data", listener: (chunk: Uint8Array) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: "data", listener: (chunk: Uint8Array) => void): this;
+    once(event: "end", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    off(event: "data", listener: (chunk: Uint8Array) => void): this;
+    off(event: "end", listener: () => void): this;
+    off(event: "error", listener: (err: Error) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    write(chunk: Uint8Array, callback?: StreamCallback): boolean;
+    end(callback?: StreamCallback): unknown;
+    destroy(err?: Error): unknown;
+}
+export type DeflateStream = StreamingCodec;
+export type InflateStream = StreamingCodec;
+export declare function asError(err: unknown): Error;

package/dist/browser/modules/archive/streaming-compress.base.js

@@ -0,0 +1,9 @@
+/**
+ * Shared types for true streaming compression.
+ *
+ * Kept in a dedicated base module so Node.js and browser implementations
+ * don't depend on each other.
+ */
+export function asError(err) {
+    return err instanceof Error ? err : new Error(String(err));
+}

package/dist/browser/modules/archive/streaming-compress.browser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Browser True Streaming Compression
+ *
+ * Uses native CompressionStream("deflate-raw") for real chunk-by-chunk streaming.
+ * Falls back to buffered compression if not supported.
+ *
+ * API compatible with Node.js version - supports .on("data"), .on("end"), .write(callback), .end()
+ */
+export type { StreamCompressOptions } from "@archive/streaming-compress.base";
+import { type DeflateStream, type InflateStream, type StreamCompressOptions } from "@archive/streaming-compress.base";
+/**
+ * Check if deflate-raw streaming compression is supported by this library.
+ *
+ * In browsers, the library always supports deflate-raw via the JS fallback.
+ * Native deflate-raw Web Streams support (CompressionStream/DecompressionStream)
+ * is used when available, but is not required.
+ */
+export declare function hasDeflateRaw(): boolean;
+/**
+ * Create a streaming DEFLATE compressor
+ */
+export declare function createDeflateStream(options?: StreamCompressOptions): DeflateStream;
+/**
+ * Create a streaming INFLATE decompressor
+ */
+export declare function createInflateStream(): InflateStream;

package/dist/browser/modules/archive/streaming-compress.browser.js

@@ -0,0 +1,296 @@
+/**
+ * Browser True Streaming Compression
+ *
+ * Uses native CompressionStream("deflate-raw") for real chunk-by-chunk streaming.
+ * Falls back to buffered compression if not supported.
+ *
+ * API compatible with Node.js version - supports .on("data"), .on("end"), .write(callback), .end()
+ */
+import { EventEmitter } from "../stream/index.browser.js";
+import { deflateRawCompressed, inflateRaw } from "./deflate-fallback.js";
+import { hasDeflateRawWebStreams } from "./compress.base.js";
+import { concatUint8Arrays } from "./utils/bytes.js";
+import { DEFAULT_COMPRESS_LEVEL } from "./defaults.js";
+import { asError } from "./streaming-compress.base.js";
+/**
+ * Check if deflate-raw streaming compression is supported by this library.
+ *
+ * In browsers, the library always supports deflate-raw via the JS fallback.
+ * Native deflate-raw Web Streams support (CompressionStream/DecompressionStream)
+ * is used when available, but is not required.
+ */
+export function hasDeflateRaw() {
+    return true;
+}
+function hasNativeDeflateRawWebStreams() {
+    return hasDeflateRawWebStreams();
+}
+class WebStreamCodec extends EventEmitter {
+    constructor(writer, reader) {
+        super();
+        this.ended = false;
+        this.writer = writer;
+        this.reader = reader;
+        this.readPromise = this._startReading();
+    }
+    async _startReading() {
+        try {
+            while (true) {
+                const { value, done } = await this.reader.read();
+                if (done) {
+                    break;
+                }
+                if (value) {
+                    this.emit("data", value);
+                }
+            }
+            this.emit("end");
+        }
+        catch (err) {
+            this.emit("error", asError(err));
+        }
+    }
+    write(chunk, callback) {
+        if (this.ended) {
+            const err = new Error("write after end");
+            if (callback) {
+                callback(err);
+            }
+            else {
+                this.emit("error", err);
+            }
+            return false;
+        }
+        this.writer
+            .write(chunk)
+            .then(() => {
+            if (callback) {
+                callback();
+            }
+        })
+            .catch(err => {
+            const error = asError(err);
+            if (callback) {
+                callback(error);
+            }
+            else {
+                this.emit("error", error);
+            }
+        });
+        return true;
+    }
+    end(callback) {
+        if (this.ended) {
+            if (callback) {
+                callback();
+            }
+            return;
+        }
+        this.ended = true;
+        this.writer
+            .close()
+            .then(() => this.readPromise)
+            .then(() => {
+            if (callback) {
+                callback();
+            }
+        })
+            .catch(err => {
+            const error = asError(err);
+            if (callback) {
+                callback(error);
+            }
+            else {
+                this.emit("error", error);
+            }
+        });
+    }
+    destroy(err) {
+        this.ended = true;
+        if (err) {
+            this.emit("error", err);
+        }
+        try {
+            this.reader.cancel(err);
+        }
+        catch {
+            // Ignore
+        }
+        try {
+            this.writer.abort(err);
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+/**
+ * Browser True Streaming Deflate using CompressionStream API
+ * Simple EventEmitter-based - emits "data" as compressed chunks arrive
+ */
+class TrueStreamingDeflate extends EventEmitter {
+    constructor(_level) {
+        super();
+        const compressionStream = new CompressionStream("deflate-raw");
+        const writer = compressionStream.writable.getWriter();
+        const reader = compressionStream.readable.getReader();
+        this.codec = new WebStreamCodec(writer, reader);
+        this.codec.on("data", chunk => this.emit("data", chunk));
+        this.codec.on("end", () => this.emit("end"));
+        this.codec.on("error", err => this.emit("error", err));
+    }
+    write(chunk, callback) {
+        return this.codec.write(chunk, callback);
+    }
+    end(callback) {
+        this.codec.end(callback);
+    }
+    destroy(err) {
+        this.codec.destroy(err);
+    }
+}
+/**
+ * Fallback Deflate - buffers all data, compresses at end
+ */
+class FallbackDeflate extends EventEmitter {
+    constructor(_level) {
+        super();
+        this.codec = new BufferedCodec(deflateRawCompressed);
+        this.codec.on("data", chunk => this.emit("data", chunk));
+        this.codec.on("end", () => this.emit("end"));
+        this.codec.on("error", err => this.emit("error", err));
+    }
+    write(chunk, callback) {
+        return this.codec.write(chunk, callback);
+    }
+    end(callback) {
+        this.codec.end(callback);
+    }
+    destroy(err) {
+        this.codec.destroy(err);
+    }
+}
+class BufferedCodec extends EventEmitter {
+    constructor(process) {
+        super();
+        this.process = process;
+        this.chunks = [];
+        this.ended = false;
+    }
+    write(chunk, callback) {
+        if (this.ended) {
+            const err = new Error("write after end");
+            if (callback) {
+                callback(err);
+            }
+            else {
+                this.emit("error", err);
+            }
+            return false;
+        }
+        this.chunks.push(chunk);
+        if (callback) {
+            queueMicrotask(() => callback());
+        }
+        return true;
+    }
+    end(callback) {
+        if (this.ended) {
+            if (callback) {
+                callback();
+            }
+            return;
+        }
+        this.ended = true;
+        try {
+            const data = concatUint8Arrays(this.chunks);
+            const output = this.process(data);
+            this.emit("data", output);
+            this.emit("end");
+            if (callback) {
+                callback();
+            }
+        }
+        catch (err) {
+            const error = asError(err);
+            this.emit("error", error);
+            if (callback) {
+                callback(error);
+            }
+        }
+    }
+    destroy(err) {
+        this.ended = true;
+        if (err) {
+            this.emit("error", err);
+        }
+    }
+}
+/**
+ * Create a streaming DEFLATE compressor
+ */
+export function createDeflateStream(options = {}) {
+    const level = options.level ?? DEFAULT_COMPRESS_LEVEL;
+    if (hasNativeDeflateRawWebStreams()) {
+        return new TrueStreamingDeflate(level);
+    }
+    else {
+        return new FallbackDeflate(level);
+    }
+}
+/**
+ * Browser True Streaming Inflate using DecompressionStream API
+ */
+class TrueStreamingInflate extends EventEmitter {
+    constructor() {
+        super();
+        const decompressionStream = new DecompressionStream("deflate-raw");
+        const writer = decompressionStream.writable.getWriter();
+        const reader = decompressionStream.readable.getReader();
+        this.codec = new WebStreamCodec(writer, reader);
+        this.codec.on("data", chunk => this.emit("data", chunk));
+        this.codec.on("end", () => this.emit("end"));
+        this.codec.on("error", err => this.emit("error", err));
+    }
+    write(chunk, callback) {
+        return this.codec.write(chunk, callback);
+    }
+    end(callback) {
+        this.codec.end(callback);
+    }
+    destroy(err) {
+        this.codec.destroy(err);
+    }
+}
+/**
+ * Fallback Inflate - buffers all data, decompresses at end
+ */
+class FallbackInflate extends EventEmitter {
+    constructor() {
+        super();
+        this.codec = new BufferedCodec(inflateRaw);
+        this.codec.on("data", chunk => this.emit("data", chunk));
+        this.codec.on("end", () => this.emit("end"));
+        this.codec.on("error", err => this.emit("error", err));
+    }
+    write(chunk, callback) {
+        return this.codec.write(chunk, callback);
+    }
+    end(callback) {
+        this.codec.end(callback);
+    }
+    destroy(err) {
+        this.codec.destroy(err);
+    }
+}
+/**
+ * Create a streaming INFLATE decompressor
+ */
+export function createInflateStream() {
+    if (hasNativeDeflateRawWebStreams()) {
+        return new TrueStreamingInflate();
+    }
+    else {
+        return new FallbackInflate();
+    }
+}

package/dist/browser/modules/archive/streaming-compress.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Node.js True Streaming Compression
+ *
+ * Uses zlib.createDeflateRaw() with explicit flush() calls for real chunk-by-chunk streaming.
+ * Each write() immediately produces compressed output without waiting for end().
+ */
+export type { DeflateStream, InflateStream, StreamCompressOptions, StreamingCodec } from "@archive/streaming-compress.base";
+import type { DeflateStream, InflateStream, StreamCompressOptions } from "@archive/streaming-compress.base";
+/**
+ * Create a true streaming DEFLATE compressor
+ * Returns a Transform stream that emits compressed data immediately after each write
+ */
+export declare function createDeflateStream(options?: StreamCompressOptions): DeflateStream;
+/**
+ * Create a true streaming INFLATE decompressor
+ */
+export declare function createInflateStream(): InflateStream;
+/**
+ * Check if true streaming deflate-raw is available
+ * In Node.js, zlib is always available, so this always returns true
+ */
+export declare function hasDeflateRaw(): boolean;

package/dist/browser/modules/archive/streaming-compress.js

@@ -0,0 +1,68 @@
+/**
+ * Node.js True Streaming Compression
+ *
+ * Uses zlib.createDeflateRaw() with explicit flush() calls for real chunk-by-chunk streaming.
+ * Each write() immediately produces compressed output without waiting for end().
+ */
+import { createDeflateRaw, createInflateRaw, constants } from "zlib";
+import { Transform } from "../stream/index.browser.js";
+import { DEFAULT_COMPRESS_LEVEL } from "./defaults.js";
+/**
+ * Wrapper around zlib DeflateRaw that flushes after every write
+ * This ensures true streaming behavior - data is emitted immediately, not buffered
+ */
+class TrueStreamingDeflate extends Transform {
+    constructor(level) {
+        super();
+        this.deflate = createDeflateRaw({ level });
+        // Forward data from deflate to this transform
+        this.deflate.on("data", chunk => {
+            this.push(chunk);
+        });
+        this.deflate.on("error", err => {
+            this.destroy(err);
+        });
+    }
+    _transform(chunk, _encoding, callback) {
+        // Write to deflate
+        this.deflate.write(chunk, writeErr => {
+            if (writeErr) {
+                callback(writeErr);
+                return;
+            }
+            // Explicitly flush to ensure data is emitted NOW, not later
+            this.deflate.flush(constants.Z_SYNC_FLUSH, () => {
+                callback();
+            });
+        });
+    }
+    _flush(callback) {
+        // End the deflate stream with Z_FINISH to write proper termination
+        // This is critical - Z_SYNC_FLUSH doesn't write the final block marker
+        this.deflate.flush(constants.Z_FINISH, () => {
+            this.deflate.end(() => {
+                callback();
+            });
+        });
+    }
+}
+/**
+ * Create a true streaming DEFLATE compressor
+ * Returns a Transform stream that emits compressed data immediately after each write
+ */
+export function createDeflateStream(options = {}) {
+    return new TrueStreamingDeflate(options.level ?? DEFAULT_COMPRESS_LEVEL);
+}
+/**
+ * Create a true streaming INFLATE decompressor
+ */
+export function createInflateStream() {
+    return createInflateRaw();
+}
+/**
+ * Check if true streaming deflate-raw is available
+ * In Node.js, zlib is always available, so this always returns true
+ */
+export function hasDeflateRaw() {
+    return true;
+}

package/dist/browser/modules/archive/streaming-zip.d.ts

@@ -0,0 +1,120 @@
+/**
+ * True Streaming ZIP creator - shared implementation.
+ *
+ * This module is intentionally platform-agnostic.
+ * - In Node builds it uses `./crc32` + `./streaming-compress` (zlib-backed).
+ * - In browser builds the bundler aliases those imports to their browser variants.
+ */
+import type { ZipTimestampMode } from "@archive/utils/timestamps";
+import type { ZipEntryInfo as UnzipZipEntryInfo } from "@archive/zip-entry-info";
+/**
+ * Internal entry info for central directory
+ */
+interface ZipEntryInfo {
+    name: Uint8Array;
+    extraField: Uint8Array;
+    flags: number;
+    crc: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    compressionMethod: number;
+    dosTime: number;
+    dosDate: number;
+    offset: number;
+}
+type CentralDirectoryEntryInfo = ZipEntryInfo;
+/**
+ * True Streaming ZIP File - compresses chunk by chunk
+ */
+export declare class ZipDeflateFile {
+    private _deflate;
+    private _crc;
+    private _uncompressedSize;
+    private _compressedSize;
+    private _finalized;
+    private _headerEmitted;
+    private _ondata;
+    private _centralDirEntryInfo;
+    private _pendingEnd;
+    private _emittedDataDescriptor;
+    private _localHeader;
+    private _completeResolve;
+    private _completeReject;
+    private _completePromise;
+    private _completeError;
+    private _dataQueue;
+    private _finalQueued;
+    readonly name: string;
+    readonly level: number;
+    readonly nameBytes: Uint8Array;
+    readonly dosTime: number;
+    readonly dosDate: number;
+    readonly extraField: Uint8Array;
+    private readonly _flags;
+    private readonly _compressionMethod;
+    private readonly _modTime;
+    constructor(name: string, options?: {
+        level?: number;
+        modTime?: Date;
+        timestamps?: ZipTimestampMode;
+    });
+    private _buildLocalHeader;
+    private _enqueueData;
+    private _flushQueue;
+    get ondata(): ((data: Uint8Array, final: boolean) => void) | undefined;
+    set ondata(cb: (data: Uint8Array, final: boolean) => void);
+    private _resolveComplete;
+    private _rejectComplete;
+    private _ensureCompletePromise;
+    private _tapCallback;
+    private _emitHeaderIfNeeded;
+    private _writeData;
+    private _endDeflateAndWait;
+    private _finalizeAfterWrite;
+    /**
+     * Push data - immediately compresses and outputs
+     * Returns a Promise that resolves when the write is complete.
+     * If final=true, it resolves after the data descriptor is emitted.
+     */
+    push(data: Uint8Array, final?: boolean, callback?: (err?: Error | null) => void): Promise<void>;
+    /**
+     * Emit local file header with Data Descriptor flag
+     */
+    private _emitHeader;
+    /**
+     * Emit Data Descriptor with CRC and sizes
+     */
+    private _emitDataDescriptor;
+    /**
+     * Returns a promise that resolves when the file is completely written
+     * (including data descriptor)
+     */
+    complete(): Promise<void>;
+    /**
+     * Get entry metadata in the same shape as unzip parser outputs.
+     * This is best-effort: writer-only fields like encryption are always false.
+     */
+    getEntryInfo(): UnzipZipEntryInfo | null;
+    /** Writer-only metadata for building the Central Directory. */
+    getCentralDirectoryEntryInfo(): CentralDirectoryEntryInfo | null;
+    isComplete(): boolean;
+}
+/**
+ * Streaming ZIP Creator - processes files sequentially
+ */
+export declare class StreamingZip {
+    private callback;
+    private entries;
+    private currentOffset;
+    private ended;
+    private endPending;
+    private fileQueue;
+    private fileQueueIndex;
+    private activeFile;
+    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void);
+    add(file: ZipDeflateFile): void;
+    private _processNextFile;
+    private _finalize;
+    end(): void;
+}
+export { StreamingZip as Zip, ZipDeflateFile as ZipDeflate };