@cj-tech-master/excelts 1.0.0 → 1.4.0

package/dist/cjs/utils/unzip/pull-stream.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Unzipper pull-stream module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PullStream = void 0;
+const stream_1 = require("stream");
+const STR_FUNCTION = "function";
+class PullStream extends stream_1.Duplex {
+    constructor() {
+        super({ decodeStrings: false, objectMode: true });
+        this.buffer = Buffer.from("");
+        this.finished = false;
+        this.on("finish", () => {
+            this.finished = true;
+            this.emit("chunk", false);
+        });
+    }
+    _write(chunk, _encoding, cb) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        this.cb = cb;
+        this.emit("chunk");
+    }
+    _read() { }
+    /**
+     * The `eof` parameter is interpreted as `file_length` if the type is number
+     * otherwise (i.e. buffer) it is interpreted as a pattern signaling end of stream
+     */
+    stream(eof, includeEof) {
+        const p = new stream_1.PassThrough();
+        let done = false;
+        const cb = () => {
+            if (typeof this.cb === STR_FUNCTION) {
+                const callback = this.cb;
+                this.cb = undefined;
+                callback();
+            }
+        };
+        const pull = () => {
+            let packet;
+            if (this.buffer && this.buffer.length) {
+                if (typeof eof === "number") {
+                    packet = this.buffer.slice(0, eof);
+                    this.buffer = this.buffer.slice(eof);
+                    eof -= packet.length;
+                    done = done || !eof;
+                }
+                else {
+                    let match = this.buffer.indexOf(eof);
+                    if (match !== -1) {
+                        // store signature match byte offset to allow us to reference
+                        // this for zip64 offset
+                        this.match = match;
+                        if (includeEof) {
+                            match = match + eof.length;
+                        }
+                        packet = this.buffer.slice(0, match);
+                        this.buffer = this.buffer.slice(match);
+                        done = true;
+                    }
+                    else {
+                        const len = this.buffer.length - eof.length;
+                        if (len <= 0) {
+                            cb();
+                        }
+                        else {
+                            packet = this.buffer.slice(0, len);
+                            this.buffer = this.buffer.slice(len);
+                        }
+                    }
+                }
+                if (packet) {
+                    p.write(packet, () => {
+                        if (this.buffer.length === 0 ||
+                            (typeof eof !== "number" && eof.length && this.buffer.length <= eof.length)) {
+                            cb();
+                        }
+                    });
+                }
+            }
+            if (!done) {
+                if (this.finished) {
+                    this.removeListener("chunk", pull);
+                    this.emit("error", new Error("FILE_ENDED"));
+                    return;
+                }
+            }
+            else {
+                this.removeListener("chunk", pull);
+                p.end();
+            }
+        };
+        this.on("chunk", pull);
+        pull();
+        return p;
+    }
+    pull(eof, includeEof) {
+        if (eof === 0) {
+            return Promise.resolve(Buffer.from(""));
+        }
+        // If we already have the required data in buffer
+        // we can resolve the request immediately
+        if (typeof eof === "number" && this.buffer.length > eof) {
+            const data = this.buffer.slice(0, eof);
+            this.buffer = this.buffer.slice(eof);
+            return Promise.resolve(data);
+        }
+        // Otherwise we stream until we have it
+        let buffer = Buffer.from("");
+        const concatStream = new stream_1.Transform({
+            transform(d, _e, cb) {
+                buffer = Buffer.concat([buffer, d]);
+                cb();
+            }
+        });
+        let rejectHandler;
+        let pullStreamRejectHandler;
+        return new Promise((resolve, reject) => {
+            rejectHandler = reject;
+            pullStreamRejectHandler = (e) => {
+                this.__emittedError = e;
+                reject(e);
+            };
+            if (this.finished) {
+                return reject(new Error("FILE_ENDED"));
+            }
+            this.once("error", pullStreamRejectHandler); // reject any errors from pullstream itself
+            this.stream(eof, includeEof)
+                .on("error", reject)
+                .pipe(concatStream)
+                .on("finish", () => {
+                resolve(buffer);
+            })
+                .on("error", reject);
+        }).finally(() => {
+            this.removeListener("error", rejectHandler);
+            this.removeListener("error", pullStreamRejectHandler);
+        });
+    }
+}
+exports.PullStream = PullStream;

package/dist/cjs/utils/utils.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.utils = exports.inherits = void 0;
 exports.delay = delay;
 exports.nop = nop;
-exports.promiseImmediate = promiseImmediate;
 exports.dateToExcel = dateToExcel;
 exports.excelToDate = excelToDate;
 exports.parsePath = parsePath;
@@ -21,26 +20,12 @@ exports.parseBoolean = parseBoolean;
 exports.range = range;
 exports.toSortedArray = toSortedArray;
 exports.objectFromProps = objectFromProps;
+exports.bufferToString = bufferToString;
 const fs_1 = __importDefault(require("fs"));
 function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 function nop() { }
-function promiseImmediate(value) {
-    return new Promise(resolve => {
-        if (global.setImmediate) {
-            setImmediate(() => {
-                resolve(value);
-            });
-        }
-        else {
-            // poorman's setImmediate - must wait at least 1ms
-            setTimeout(() => {
-                resolve(value);
-            }, 1);
-        }
-    });
-}
 // useful stuff
 const inherits = function (cls, superCtor, statics, prototype) {
     cls.super_ = superCtor;
@@ -213,7 +198,6 @@ function objectFromProps(props, value = null) {
 /** @deprecated Import functions directly instead of using the utils object */
 exports.utils = {
     nop,
-    promiseImmediate,
     inherits: exports.inherits,
     dateToExcel,
     excelToDate,
@@ -232,3 +216,15 @@ exports.utils = {
     toSortedArray,
     objectFromProps
 };
+// TextDecoder is available in ES2020+ and all modern browsers/Node.js
+const textDecoder = new TextDecoder("utf-8");
+/**
+ * Convert a Buffer or ArrayBuffer to a UTF-8 string
+ * Works in both Node.js and browser environments
+ */
+function bufferToString(chunk) {
+    if (typeof chunk === "string") {
+        return chunk;
+    }
+    return textDecoder.decode(chunk);
+}

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

@@ -7,8 +7,6 @@ exports.ZipWriter = void 0;
 const events_1 = __importDefault(require("events"));
 const fflate_1 = require("fflate");
 const stream_buf_js_1 = require("./stream-buf");
-const browser_buffer_encode_js_1 = require("./browser-buffer-encode");
-const browser_js_1 = require("./browser");
 // =============================================================================
 // The ZipWriter class
 // Packs streamed data into an output zip stream
@@ -19,6 +17,10 @@ class ZipWriter extends events_1.default.EventEmitter {
             type: "nodebuffer",
             compression: "DEFLATE"
         }, options);
+        // Default compression level is 6 (good balance of speed and size)
+        // 0 = no compression, 9 = best compression
+        const level = this.options.compressionOptions?.level ?? 6;
+        this.compressionLevel = Math.max(0, Math.min(9, level));
         this.files = {};
         this.stream = new stream_buf_js_1.StreamBuf();
         this.finalized = false;
@@ -38,42 +40,36 @@ class ZipWriter extends events_1.default.EventEmitter {
     append(data, options) {
         let buffer;
         if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
-            // Use Buffer.from for efficient base64 decoding
+            // Decode base64 data - Buffer.from works in both Node.js and browser (via polyfill)
             const base64Data = typeof data === "string" ? data : data.toString();
-            if (browser_js_1.isBrowser) {
-                // Browser: use atob with optimized Uint8Array conversion
-                const binaryString = atob(base64Data);
-                const len = binaryString.length;
-                buffer = new Uint8Array(len);
-                // Use a single loop with cached length for better performance
-                for (let i = 0; i < len; i++) {
-                    buffer[i] = binaryString.charCodeAt(i);
-                }
-            }
-            else {
-                // Node.js: use efficient Buffer.from
-                buffer = Buffer.from(base64Data, "base64");
-            }
+            buffer = Buffer.from(base64Data, "base64");
+        }
+        else if (typeof data === "string") {
+            // Convert string to Buffer - works in both environments
+            buffer = Buffer.from(data, "utf8");
+        }
+        else if (Buffer.isBuffer(data)) {
+            // Buffer extends Uint8Array, fflate can use it directly - no copy needed
+            buffer = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            // Handle typed arrays - create view without copy
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer) {
+            // Handle ArrayBuffer directly
+            buffer = new Uint8Array(data);
         }
         else {
-            if (typeof data === "string") {
-                // Convert string to Uint8Array
-                if (browser_js_1.isBrowser) {
-                    buffer = (0, browser_buffer_encode_js_1.stringToBuffer)(data);
-                }
-                else {
-                    buffer = Buffer.from(data, "utf8");
-                }
-            }
-            else if (Buffer.isBuffer(data)) {
-                buffer = new Uint8Array(data);
-            }
-            else {
-                buffer = data;
-            }
+            // Assume it's already a Uint8Array or compatible type
+            buffer = data;
         }
         // Add file to zip using streaming API
-        const zipFile = new fflate_1.ZipPassThrough(options.name);
+        // Use ZipDeflate for compression or ZipPassThrough for no compression
+        const useCompression = this.options.compression !== "STORE";
+        const zipFile = useCompression
+            ? new fflate_1.ZipDeflate(options.name, { level: this.compressionLevel })
+            : new fflate_1.ZipPassThrough(options.name);
         this.zip.add(zipFile);
         zipFile.push(buffer, true); // true = final chunk
     }

package/dist/cjs/xlsx/xlsx.js

@@ -11,7 +11,6 @@ const zip_stream_js_1 = require("../utils/zip-stream");
 const stream_buf_js_1 = require("../utils/stream-buf");
 const utils_js_1 = require("../utils/utils");
 const xml_stream_js_1 = require("../utils/xml-stream");
-const browser_buffer_decode_js_1 = require("../utils/browser-buffer-decode");
 const styles_xform_js_1 = require("./xform/style/styles-xform");
 const core_xform_js_1 = require("./xform/core/core-xform");
 const shared_strings_xform_js_1 = require("./xform/strings/shared-strings-xform");
@@ -377,7 +376,7 @@ class XLSX {
                         readableObjectMode: true,
                         writableObjectMode: true
                     });
-                    const content = (0, browser_buffer_decode_js_1.bufferToString)(Buffer.from(entry.data));
+                    const content = (0, utils_js_1.bufferToString)(Buffer.from(entry.data));
                     stream.end(content);
                 }
                 let match;

package/dist/esm/index.browser.js

@@ -1,3 +1,4 @@
 export { Workbook } from "./doc/workbook.js";
 export * from "./doc/enums.js";
 export * from "./types.js";
+export * from "./utils/sheet-utils.js";

package/dist/esm/index.js

@@ -18,3 +18,4 @@ export { DataValidations } from "./doc/data-validations.js";
 export * from "./doc/enums.js";
 // Export all type definitions
 export * from "./types.js";
+export * from "./utils/sheet-utils.js";

package/dist/esm/stream/xlsx/workbook-reader.js

@@ -3,7 +3,6 @@ import { EventEmitter } from "events";
 import { PassThrough, Readable } from "stream";
 import os from "os";
 import { join } from "path";
-import { Parse } from "unzipper";
 import { iterateStream } from "../../utils/iterate-stream.js";
 import { parseSax } from "../../utils/parse-sax.js";
 import { StylesXform } from "../../xlsx/xform/style/styles-xform.js";
@@ -11,6 +10,7 @@ import { WorkbookXform } from "../../xlsx/xform/book/workbook-xform.js";
 import { RelationshipsXform } from "../../xlsx/xform/core/relationships-xform.js";
 import { WorksheetReader } from "./worksheet-reader.js";
 import { HyperlinkReader } from "./hyperlink-reader.js";
+import { createParse } from "../../utils/unzip/parse.js";
 class WorkbookReader extends EventEmitter {
     constructor(input, options = {}) {
         super();
@@ -70,7 +70,7 @@ class WorkbookReader extends EventEmitter {
             this.options = options;
         }
         const stream = (this.stream = this._getStream(input || this.input));
-        const zip = Parse({ forceStream: true });
+        const zip = createParse({ forceStream: true });
         // Handle pipe errors to prevent unhandled rejection
         stream.on("error", (err) => {
             zip.emit("error", err);

package/dist/esm/stream/xlsx/workbook-writer.js

@@ -1,5 +1,5 @@
 import fs from "fs";
-import { Zip, ZipPassThrough } from "fflate";
+import { Zip, ZipDeflate } from "fflate";
 import { StreamBuf } from "../../utils/stream-buf.js";
 import { RelType } from "../../xlsx/rel-type.js";
 import { StylesXform } from "../../xlsx/xform/style/styles-xform.js";
@@ -30,6 +30,10 @@ class WorkbookWriter {
         this._worksheets = [];
         this.views = [];
         this.zipOptions = options.zip;
+        // Extract compression level from zip options (supports both zlib.level and compressionOptions.level)
+        // Default compression level is 6 (good balance of speed and size)
+        const level = options.zip?.zlib?.level ?? options.zip?.compressionOptions?.level ?? 6;
+        this.compressionLevel = Math.max(0, Math.min(9, level));
         this.media = [];
         this.commentRefs = [];
         // Create fflate Zip instance
@@ -61,8 +65,8 @@ class WorkbookWriter {
     }
     _openStream(path) {
         const stream = new StreamBuf({ bufSize: 65536, batch: true });
-        // Create a ZipPassThrough for this file
-        const zipFile = new ZipPassThrough(path);
+        // Create a ZipDeflate for this file with compression
+        const zipFile = new ZipDeflate(path, { level: this.compressionLevel });
         this.zip.add(zipFile);
         // Don't pause the stream - we need data events to flow
         // The original implementation used archiver which consumed the stream internally
@@ -81,8 +85,8 @@ class WorkbookWriter {
         return stream;
     }
     _addFile(data, name, base64) {
-        // Helper method to add a file to the zip using fflate
-        const zipFile = new ZipPassThrough(name);
+        // Helper method to add a file to the zip using fflate with compression
+        const zipFile = new ZipDeflate(name, { level: this.compressionLevel });
         this.zip.add(zipFile);
         let buffer;
         if (base64) {