@cj-tech-master/excelts 1.6.3 → 2.0.0-canary.20251228013952.4f2c3c6

package/dist/cjs/utils/zip/streaming-zip.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * Streaming ZIP creator - fflate-compatible API
+ *
+ * This module provides a streaming ZIP API compatible with fflate's Zip/ZipDeflate,
+ * but uses native zlib compression for better performance.
+ *
+ * Usage:
+ * ```ts
+ * const zip = new StreamingZip((err, data, final) => {
+ *   if (err) handleError(err);
+ *   else {
+ *     stream.write(data);
+ *     if (final) stream.end();
+ *   }
+ * });
+ *
+ * const file = new ZipDeflateFile("path/file.txt", { level: 6 });
+ * zip.add(file);
+ * file.push(data1);
+ * file.push(data2, true); // true = final chunk
+ *
+ * zip.end();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipDeflate = exports.Zip = exports.StreamingZip = exports.ZipDeflateFile = void 0;
+const crc32_1 = require("./crc32");
+const compress_1 = require("./compress");
+// ZIP signature constants
+const LOCAL_FILE_HEADER_SIG = 0x04034b50;
+const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
+const END_OF_CENTRAL_DIR_SIG = 0x06054b50;
+// ZIP version constants
+const VERSION_NEEDED = 20; // 2.0 - supports DEFLATE
+const VERSION_MADE_BY = 20; // 2.0
+// Compression methods
+const COMPRESSION_STORE = 0;
+const COMPRESSION_DEFLATE = 8;
+const encoder = new TextEncoder();
+/**
+ * Convert Date to DOS time format
+ */
+function dateToDos(date) {
+    const dosTime = ((date.getHours() & 0x1f) << 11) |
+        ((date.getMinutes() & 0x3f) << 5) |
+        ((date.getSeconds() >> 1) & 0x1f);
+    const dosDate = (((date.getFullYear() - 1980) & 0x7f) << 9) |
+        (((date.getMonth() + 1) & 0x0f) << 5) |
+        (date.getDate() & 0x1f);
+    return [dosTime, dosDate];
+}
+/**
+ * ZipDeflate-compatible file stream
+ * Collects data chunks, compresses on finalization
+ */
+class ZipDeflateFile {
+    constructor(name, options) {
+        this.chunks = [];
+        this.totalSize = 0;
+        this.finalized = false;
+        this._ondata = null;
+        this.name = name;
+        this.level = options?.level ?? 6;
+    }
+    /**
+     * Set data callback (called by StreamingZip)
+     */
+    set ondata(cb) {
+        this._ondata = cb;
+    }
+    /**
+     * Push data to the file
+     * @param data - Data chunk
+     * @param final - Whether this is the final chunk
+     */
+    push(data, final = false) {
+        if (this.finalized) {
+            throw new Error("Cannot push to finalized ZipDeflateFile");
+        }
+        if (data.length > 0) {
+            this.chunks.push(data);
+            this.totalSize += data.length;
+        }
+        if (final) {
+            this.finalized = true;
+            this._flush();
+        }
+    }
+    /**
+     * Flush collected data through compression and emit
+     */
+    _flush() {
+        if (!this._ondata) {
+            return;
+        }
+        // Combine chunks
+        let uncompressed;
+        if (this.chunks.length === 0) {
+            uncompressed = new Uint8Array(0);
+        }
+        else if (this.chunks.length === 1) {
+            uncompressed = this.chunks[0];
+        }
+        else {
+            uncompressed = new Uint8Array(this.totalSize);
+            let offset = 0;
+            for (const chunk of this.chunks) {
+                uncompressed.set(chunk, offset);
+                offset += chunk.length;
+            }
+        }
+        // Compress if level > 0 and data is not empty
+        const shouldCompress = this.level > 0 && uncompressed.length > 0;
+        const compressed = shouldCompress
+            ? (0, compress_1.compressSync)(uncompressed, { level: this.level })
+            : uncompressed;
+        // Build local file header + data
+        const nameBytes = encoder.encode(this.name);
+        const crcValue = (0, crc32_1.crc32)(uncompressed);
+        const [dosTime, dosDate] = dateToDos(new Date());
+        // Local file header (30 bytes + filename)
+        const header = new Uint8Array(30 + nameBytes.length);
+        const view = new DataView(header.buffer);
+        view.setUint32(0, LOCAL_FILE_HEADER_SIG, true);
+        view.setUint16(4, VERSION_NEEDED, true);
+        view.setUint16(6, 0x0800, true); // UTF-8 flag
+        view.setUint16(8, shouldCompress ? COMPRESSION_DEFLATE : COMPRESSION_STORE, true);
+        view.setUint16(10, dosTime, true);
+        view.setUint16(12, dosDate, true);
+        view.setUint32(14, crcValue, true);
+        view.setUint32(18, compressed.length, true);
+        view.setUint32(22, uncompressed.length, true);
+        view.setUint16(26, nameBytes.length, true);
+        view.setUint16(28, 0, true); // Extra field length
+        header.set(nameBytes, 30);
+        // Store info for central directory BEFORE emitting data
+        // (StreamingZip reads this in the final callback)
+        this._entryInfo = {
+            name: nameBytes,
+            crc: crcValue,
+            compressedSize: compressed.length,
+            uncompressedSize: uncompressed.length,
+            compressionMethod: shouldCompress ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            dosTime,
+            dosDate,
+            offset: -1 // Will be set by StreamingZip
+        };
+        // Emit header
+        this._ondata(header, false);
+        // Emit compressed data (final chunk)
+        this._ondata(compressed, true);
+        // Clear chunks for GC
+        this.chunks.length = 0;
+    }
+    /**
+     * Get entry info (called by StreamingZip after finalization)
+     */
+    getEntryInfo() {
+        return this._entryInfo || null;
+    }
+}
+exports.ZipDeflateFile = ZipDeflateFile;
+exports.ZipDeflate = ZipDeflateFile;
+/**
+ * Streaming ZIP - fflate Zip-compatible API
+ * Creates ZIP files in a streaming manner
+ */
+class StreamingZip {
+    /**
+     * Create a streaming ZIP
+     * @param callback - Called with (err, data, final) as data becomes available
+     */
+    constructor(callback) {
+        this.entries = [];
+        this.currentOffset = 0;
+        this.ended = false;
+        this.callback = callback;
+    }
+    /**
+     * Add a file to the ZIP
+     * @param file - ZipDeflateFile instance
+     */
+    add(file) {
+        if (this.ended) {
+            throw new Error("Cannot add files after calling end()");
+        }
+        // Capture offset when first data is written, not when add() is called
+        // This is important because streaming files may have data pushed later
+        let startOffset = -1;
+        file.ondata = (data, final) => {
+            // Capture offset on first data chunk
+            if (startOffset === -1) {
+                startOffset = this.currentOffset;
+            }
+            this.currentOffset += data.length;
+            this.callback(null, data, false);
+            if (final) {
+                // Get entry info and set offset
+                const entryInfo = file.getEntryInfo();
+                if (entryInfo) {
+                    entryInfo.offset = startOffset;
+                    this.entries.push(entryInfo);
+                }
+            }
+        };
+    }
+    /**
+     * Finalize the ZIP
+     * Writes central directory and end-of-central-directory record
+     */
+    end() {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
+        const centralDirOffset = this.currentOffset;
+        const centralDirChunks = [];
+        // Build central directory headers
+        for (const entry of this.entries) {
+            const header = new Uint8Array(46 + entry.name.length);
+            const view = new DataView(header.buffer);
+            view.setUint32(0, CENTRAL_DIR_HEADER_SIG, true);
+            view.setUint16(4, VERSION_MADE_BY, true);
+            view.setUint16(6, VERSION_NEEDED, true);
+            view.setUint16(8, 0x0800, true); // UTF-8 flag
+            view.setUint16(10, entry.compressionMethod, true);
+            view.setUint16(12, entry.dosTime, true);
+            view.setUint16(14, entry.dosDate, true);
+            view.setUint32(16, entry.crc, true);
+            view.setUint32(20, entry.compressedSize, true);
+            view.setUint32(24, entry.uncompressedSize, true);
+            view.setUint16(28, entry.name.length, true);
+            view.setUint16(30, 0, true); // Extra field length
+            view.setUint16(32, 0, true); // Comment length
+            view.setUint16(34, 0, true); // Disk number start
+            view.setUint16(36, 0, true); // Internal file attributes
+            view.setUint32(38, 0, true); // External file attributes
+            view.setUint32(42, entry.offset, true);
+            header.set(entry.name, 46);
+            centralDirChunks.push(header);
+        }
+        // Emit central directory
+        for (const chunk of centralDirChunks) {
+            this.callback(null, chunk, false);
+        }
+        const centralDirSize = centralDirChunks.reduce((sum, c) => sum + c.length, 0);
+        // Build end of central directory
+        const eocd = new Uint8Array(22);
+        const eocdView = new DataView(eocd.buffer);
+        eocdView.setUint32(0, END_OF_CENTRAL_DIR_SIG, true);
+        eocdView.setUint16(4, 0, true); // Disk number
+        eocdView.setUint16(6, 0, true); // Disk with central dir
+        eocdView.setUint16(8, this.entries.length, true);
+        eocdView.setUint16(10, this.entries.length, true);
+        eocdView.setUint32(12, centralDirSize, true);
+        eocdView.setUint32(16, centralDirOffset, true);
+        eocdView.setUint16(20, 0, true); // Comment length
+        // Emit end of central directory (final chunk)
+        this.callback(null, eocd, true);
+    }
+}
+exports.StreamingZip = StreamingZip;
+exports.Zip = StreamingZip;

package/dist/cjs/utils/zip/zip-builder.js

@@ -26,8 +26,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZipBuilder = void 0;
 exports.createZip = createZip;
 exports.createZipSync = createZipSync;
-const crc32_js_1 = require("./crc32");
-const compress_js_1 = require("./compress");
+const crc32_1 = require("./crc32");
+const compress_1 = require("./compress");
 // ZIP signature constants
 const LOCAL_FILE_HEADER_SIG = 0x04034b50;
 const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
@@ -156,12 +156,12 @@ async function createZip(entries, options = {}) {
         const [dosTime, dosDate] = dateToDos(modDate);
         // Compress data
         const isCompressed = level > 0 && entry.data.length > 0;
-        const compressedData = isCompressed ? await (0, compress_js_1.compress)(entry.data, { level }) : entry.data;
+        const compressedData = isCompressed ? await (0, compress_1.compress)(entry.data, { level }) : entry.data;
         const processedEntry = {
             name: nameBytes,
             data: entry.data,
             compressedData,
-            crc: (0, crc32_js_1.crc32)(entry.data),
+            crc: (0, crc32_1.crc32)(entry.data),
             compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
             modTime: dosTime,
             modDate: dosDate,
@@ -221,12 +221,12 @@ function createZipSync(entries, options = {}) {
         const [dosTime, dosDate] = dateToDos(modDate);
         // Compress data
         const isCompressed = level > 0 && entry.data.length > 0;
-        const compressedData = isCompressed ? (0, compress_js_1.compressSync)(entry.data, { level }) : entry.data;
+        const compressedData = isCompressed ? (0, compress_1.compressSync)(entry.data, { level }) : entry.data;
         const processedEntry = {
             name: nameBytes,
             data: entry.data,
             compressedData,
-            crc: (0, crc32_js_1.crc32)(entry.data),
+            crc: (0, crc32_1.crc32)(entry.data),
             compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
             modTime: dosTime,
             modDate: dosDate,
@@ -294,13 +294,13 @@ class ZipBuilder {
         // Compress data
         const isCompressed = this.level > 0 && entry.data.length > 0;
         const compressedData = isCompressed
-            ? await (0, compress_js_1.compress)(entry.data, { level: this.level })
+            ? await (0, compress_1.compress)(entry.data, { level: this.level })
             : entry.data;
         const processedEntry = {
             name: nameBytes,
             data: entry.data,
             compressedData,
-            crc: (0, crc32_js_1.crc32)(entry.data),
+            crc: (0, crc32_1.crc32)(entry.data),
             compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
             modTime: dosTime,
             modDate: dosDate,
@@ -326,13 +326,13 @@ class ZipBuilder {
         // Compress data
         const isCompressed = this.level > 0 && entry.data.length > 0;
         const compressedData = isCompressed
-            ? (0, compress_js_1.compressSync)(entry.data, { level: this.level })
+            ? (0, compress_1.compressSync)(entry.data, { level: this.level })
             : entry.data;
         const processedEntry = {
             name: nameBytes,
             data: entry.data,
             compressedData,
-            crc: (0, crc32_js_1.crc32)(entry.data),
+            crc: (0, crc32_1.crc32)(entry.data),
             compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
             modTime: dosTime,
             modDate: dosDate,

package/dist/cjs/utils/zip-stream.browser.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipWriter = void 0;
+const zip_builder_1 = require("./zip/zip-builder");
+const stream_buf_browser_1 = require("./stream-buf.browser");
+// Helper function for base64 decoding in browser
+function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+// =============================================================================
+// The ZipWriter class - Browser version without Node.js events dependency
+// Packs streamed data into an output zip stream
+class ZipWriter {
+    constructor(options) {
+        this.finalized = false;
+        this.pendingWrites = [];
+        this.events = new Map();
+        const level = options?.compression === "STORE"
+            ? 0
+            : Math.max(0, Math.min(9, options?.compressionOptions?.level ?? 1));
+        this.stream = new stream_buf_browser_1.StreamBuf();
+        this.zipBuilder = new zip_builder_1.ZipBuilder({ level });
+    }
+    // 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);
+    }
+    append(data, options) {
+        let buffer;
+        if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
+            const base64Data = typeof data === "string" ? data : String(data);
+            buffer = base64ToUint8Array(base64Data);
+        }
+        else if (typeof data === "string") {
+            buffer = new TextEncoder().encode(data);
+        }
+        else if (data instanceof Uint8Array) {
+            buffer = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer) {
+            buffer = new Uint8Array(data);
+        }
+        else {
+            buffer = data;
+        }
+        const writePromise = this.zipBuilder
+            .addFile({ name: options.name, data: buffer })
+            .then(chunks => {
+            for (const chunk of chunks) {
+                this.stream.write(new Uint8Array(chunk));
+            }
+        });
+        this.pendingWrites.push(writePromise);
+    }
+    push(chunk) {
+        return this.stream.push(chunk);
+    }
+    async finalize() {
+        if (this.finalized) {
+            return;
+        }
+        this.finalized = true;
+        await Promise.all(this.pendingWrites);
+        const finalChunks = this.zipBuilder.finalize();
+        for (const chunk of finalChunks) {
+            this.stream.write(new Uint8Array(chunk));
+        }
+        this.stream.end();
+        this.emit("finish");
+    }
+    // ==========================================================================
+    // Stream.Readable interface
+    read(size) {
+        return this.stream.read(size);
+    }
+    setEncoding(encoding) {
+        return this.stream.setEncoding(encoding);
+    }
+    pause() {
+        return this.stream.pause();
+    }
+    resume() {
+        return this.stream.resume();
+    }
+    isPaused() {
+        return this.stream.isPaused();
+    }
+    pipe(destination) {
+        return this.stream.pipe(destination);
+    }
+    unpipe(destination) {
+        return this.stream.unpipe(destination);
+    }
+    unshift() {
+        return this.stream.unshift();
+    }
+    wrap() {
+        return this.stream.wrap();
+    }
+}
+exports.ZipWriter = ZipWriter;

package/dist/cjs/utils/zip-stream.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZipWriter = void 0;
 const events_1 = __importDefault(require("events"));
-const index_js_1 = require("./zip/index");
-const stream_buf_js_1 = require("./stream-buf");
+const index_1 = require("./zip/index");
+const stream_buf_1 = require("./stream-buf");
 // =============================================================================
 // The ZipWriter class
 // Packs streamed data into an output zip stream
@@ -22,8 +22,8 @@ class ZipWriter extends events_1.default.EventEmitter {
         const level = options?.compression === "STORE"
             ? 0
             : Math.max(0, Math.min(9, options?.compressionOptions?.level ?? 1));
-        this.stream = new stream_buf_js_1.StreamBuf();
-        this.zipBuilder = new index_js_1.ZipBuilder({ level });
+        this.stream = new stream_buf_1.StreamBuf();
+        this.zipBuilder = new index_1.ZipBuilder({ level });
     }
     append(data, options) {
         let buffer;

package/dist/cjs/xlsx/xform/base-xform.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseXform = void 0;
-const parse_sax_js_1 = require("../../utils/parse-sax");
-const xml_stream_js_1 = require("../../utils/xml-stream");
+const parse_sax_1 = require("../../utils/parse-sax");
+const xml_stream_1 = require("../../utils/xml-stream");
 // Base class for Xforms
 class BaseXform {
     // ============================================================
@@ -65,7 +65,7 @@ class BaseXform {
         return this.model;
     }
     async parseStream(stream) {
-        return this.parse((0, parse_sax_js_1.parseSax)(stream));
+        return this.parse((0, parse_sax_1.parseSax)(stream));
     }
     get xml() {
         // convenience function to get the xml of this.model
@@ -73,7 +73,7 @@ class BaseXform {
         return this.toXml(this.model);
     }
     toXml(model) {
-        const xmlStream = new xml_stream_js_1.XmlStream();
+        const xmlStream = new xml_stream_1.XmlStream();
         this.render(xmlStream, model);
         return xmlStream.xml;
     }

package/dist/cjs/xlsx/xform/book/defined-name-xform.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefinedNamesXform = void 0;
-const base_xform_js_1 = require("../base-xform");
-const col_cache_js_1 = require("../../../utils/col-cache");
-class DefinedNamesXform extends base_xform_js_1.BaseXform {
+const base_xform_1 = require("../base-xform");
+const col_cache_1 = require("../../../utils/col-cache");
+class DefinedNamesXform extends base_xform_1.BaseXform {
     constructor() {
         super();
         this._parsedText = [];
@@ -69,7 +69,7 @@ function isValidRange(range) {
         return false;
     }
     try {
-        const decoded = col_cache_js_1.colCache.decodeEx(range);
+        const decoded = col_cache_1.colCache.decodeEx(range);
         // For cell ranges: row/col or top/bottom/left/right should be valid numbers
         // For row ranges ($1:$2): top/bottom are numbers, left/right are null
         // For column ranges ($A:$B): left/right are numbers, top/bottom are null

package/dist/cjs/xlsx/xform/book/sheet-xform.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorksheetXform = void 0;
-const utils_js_1 = require("../../../utils/utils");
-const base_xform_js_1 = require("../base-xform");
-class WorksheetXform extends base_xform_js_1.BaseXform {
+const utils_1 = require("../../../utils/utils");
+const base_xform_1 = require("../base-xform");
+class WorksheetXform extends base_xform_1.BaseXform {
     render(xmlStream, model) {
         xmlStream.leafNode("sheet", {
             sheetId: model.id,
@@ -15,7 +15,7 @@ class WorksheetXform extends base_xform_js_1.BaseXform {
     parseOpen(node) {
         if (node.name === "sheet") {
             this.model = {
-                name: (0, utils_js_1.xmlDecode)(node.attributes.name),
+                name: (0, utils_1.xmlDecode)(node.attributes.name),
                 id: parseInt(node.attributes.sheetId, 10),
                 state: node.attributes.state,
                 rId: node.attributes["r:id"]

package/dist/cjs/xlsx/xform/book/workbook-calc-properties-xform.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkbookCalcPropertiesXform = void 0;
-const base_xform_js_1 = require("../base-xform");
-class WorkbookCalcPropertiesXform extends base_xform_js_1.BaseXform {
+const base_xform_1 = require("../base-xform");
+class WorkbookCalcPropertiesXform extends base_xform_1.BaseXform {
     render(xmlStream, model) {
         xmlStream.leafNode("calcPr", {
             calcId: 171027,

package/dist/cjs/xlsx/xform/book/workbook-pivot-cache-xform.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkbookPivotCacheXform = void 0;
-const base_xform_js_1 = require("../base-xform");
-class WorkbookPivotCacheXform extends base_xform_js_1.BaseXform {
+const base_xform_1 = require("../base-xform");
+class WorkbookPivotCacheXform extends base_xform_1.BaseXform {
     render(xmlStream, model) {
         xmlStream.leafNode("pivotCache", {
             cacheId: model.cacheId,

package/dist/cjs/xlsx/xform/book/workbook-properties-xform.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkbookPropertiesXform = void 0;
-const base_xform_js_1 = require("../base-xform");
-class WorkbookPropertiesXform extends base_xform_js_1.BaseXform {
+const base_xform_1 = require("../base-xform");
+class WorkbookPropertiesXform extends base_xform_1.BaseXform {
     render(xmlStream, model) {
         xmlStream.leafNode("workbookPr", {
             date1904: model.date1904 ? 1 : undefined,

package/dist/cjs/xlsx/xform/book/workbook-view-xform.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkbookViewXform = void 0;
-const base_xform_js_1 = require("../base-xform");
-class WorkbookViewXform extends base_xform_js_1.BaseXform {
+const base_xform_1 = require("../base-xform");
+class WorkbookViewXform extends base_xform_1.BaseXform {
     render(xmlStream, model) {
         const attributes = {
             xWindow: model.x || 0,