@cj-tech-master/excelts 4.2.0 → 4.2.1-canary.20260111102127.f808a37

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

@@ -16,20 +16,34 @@ export class Writable extends NodeWritable {
     constructor(options) {
         // If wrapping an existing stream, proxy to it
         if (options?.stream) {
+            const underlying = options.stream;
             // Create a pass-through wrapper that proxies to the underlying stream
             super({
                 highWaterMark: options?.highWaterMark,
                 objectMode: options?.objectMode,
                 write(chunk, encoding, callback) {
-                    options.stream.write(chunk, encoding, callback);
+                    underlying.write(chunk, encoding, callback);
                 },
                 final(callback) {
-                    options.stream.end(callback);
+                    underlying.end(callback);
                 }
             });
-            // Proxy events from underlying stream
-            options.stream.on("error", err => this.emit("error", err));
-            options.stream.on("close", () => this.emit("close"));
+            // Proxy events from underlying stream, but ensure we clean up listeners so
+            // the underlying stream cannot retain this wrapper longer than necessary.
+            const onUnderlyingError = (err) => {
+                this.emit("error", err);
+            };
+            const onUnderlyingClose = () => {
+                this.emit("close");
+            };
+            const cleanup = () => {
+                underlying.off("error", onUnderlyingError);
+                underlying.off("close", onUnderlyingClose);
+            };
+            underlying.on("error", onUnderlyingError);
+            underlying.on("close", onUnderlyingClose);
+            this.once("close", cleanup);
+            this.once("finish", cleanup);
         }
         else {
             super({
@@ -57,17 +71,16 @@ export function normalizeWritable(stream) {
     if (stream instanceof Writable) {
         return stream;
     }
-    // Node.js Writable: accept structurally even if typed as unknown.
+    // Node.js Writable: already compatible, avoid extra wrapper allocation.
     if (stream instanceof NodeWritable) {
-        return new Writable({ stream: stream });
+        return stream;
     }
     // Web WritableStream: detect by getWriter() (avoid relying on global WritableStream).
     if (stream?.getWriter) {
-        const nodeWritable = NodeWritable.fromWeb(stream);
-        return new Writable({ stream: nodeWritable });
+        return NodeWritable.fromWeb(stream);
     }
-    // Assume it structurally matches Node's Writable; wrap for consistent API.
-    return new Writable({ stream: stream });
+    // Assume it structurally matches Node's Writable.
+    return stream;
 }
 // Import for internal use
 import { textDecoder } from "./shared.js";
@@ -180,12 +193,13 @@ export function finished(stream, optionsOrCallback, callback) {
     const promise = new Promise((resolve, reject) => {
         const normalizedStream = toNodePipelineStream(stream);
         nodeFinished(normalizedStream, options, (err) => {
-            if (err && !(options && options.error)) {
+            // Node.js semantics: options.error defaults to true (report errors).
+            // If options.error === false, ignore errors and resolve.
+            if (err && options?.error !== false) {
                 reject(err);
+                return;
             }
-            else {
-                resolve();
-            }
+            resolve();
         });
     });
     if (cb) {
@@ -533,13 +547,28 @@ export function addAbortSignal(signal, stream) {
         stream.destroy(new Error("Aborted"));
         return stream;
     }
+    const cleanup = () => {
+        signal.removeEventListener("abort", onAbort);
+        stream.off?.("close", onDone);
+        stream.off?.("end", onDone);
+        stream.off?.("finish", onDone);
+        stream.off?.("error", onError);
+    };
     const onAbort = () => {
+        cleanup();
         stream.destroy(new Error("Aborted"));
     };
+    const onDone = () => {
+        cleanup();
+    };
+    const onError = () => {
+        cleanup();
+    };
     signal.addEventListener("abort", onAbort, { once: true });
-    stream.on("close", () => {
-        signal.removeEventListener("abort", onAbort);
-    });
+    stream.once?.("close", onDone);
+    stream.once?.("end", onDone);
+    stream.once?.("finish", onDone);
+    stream.once?.("error", onError);
     return stream;
 }
 /**
@@ -582,56 +611,109 @@ export function compose(...transforms) {
     if (len === 1 && isNativeTransform(transforms[0])) {
         return transforms[0];
     }
-    // Chain all transforms together
+    // Chain all transforms together once.
     for (let i = 0; i < len - 1; i++) {
         transforms[i].pipe(transforms[i + 1]);
     }
-    // Create a Duplex that writes to first and reads from last
     const first = transforms[0];
     const last = transforms[len - 1];
-    // Create a PassThrough as the composed stream
-    const composed = new PassThrough({ objectMode: first.readableObjectMode });
-    // Store original methods for forwarding
-    const passthroughWrite = composed.write.bind(composed);
-    const passthroughEnd = composed.end.bind(composed);
-    // Override write to write to first transform
-    composed.write = function (chunk, encodingOrCallback, callback) {
-        if (typeof encodingOrCallback === "function") {
-            return first.write(chunk, encodingOrCallback);
-        }
-        return first.write(chunk, encodingOrCallback, callback);
-    };
-    // Override end to end first transform
-    composed.end = function (chunkOrCallback, encodingOrCallback, callback) {
-        if (typeof chunkOrCallback === "function") {
-            first.end(chunkOrCallback);
+    // Use a private output stream so we don't have to monkey-patch `write()` on the
+    // public composed stream (which would break piping into it).
+    const output = new PassThrough({ objectMode: last.readableObjectMode ?? true });
+    last.pipe(output);
+    let outputEnded = false;
+    const pumpOutput = (target) => {
+        if (outputEnded) {
+            return;
         }
-        else if (typeof encodingOrCallback === "function") {
-            first.end(chunkOrCallback, encodingOrCallback);
+        while (true) {
+            const chunk = output.read();
+            if (chunk === null) {
+                break;
+            }
+            if (!target.push(chunk)) {
+                break;
+            }
         }
-        else {
-            first.end(chunkOrCallback, encodingOrCallback, callback);
+    };
+    const composed = new Transform({
+        readableObjectMode: last.readableObjectMode,
+        writableObjectMode: first.writableObjectMode,
+        transform(chunk, encoding, callback) {
+            try {
+                // Forward writes into the head of the chain.
+                first.write(chunk, encoding, callback);
+            }
+            catch (err) {
+                callback(err);
+            }
+        },
+        flush(callback) {
+            // End the head of the chain; readable completion is driven by `output` ending.
+            const onFinish = () => {
+                cleanupFlush();
+                callback();
+            };
+            const onError = (err) => {
+                cleanupFlush();
+                callback(err);
+            };
+            const cleanupFlush = () => {
+                first.off?.("finish", onFinish);
+                first.off?.("error", onError);
+            };
+            first.once?.("finish", onFinish);
+            first.once?.("error", onError);
+            first.end();
+        },
+        read() {
+            pumpOutput(this);
+        },
+        destroy(err, callback) {
+            try {
+                output.destroy(err ?? undefined);
+                for (const t of transforms) {
+                    t.destroy?.(err ?? undefined);
+                }
+            }
+            finally {
+                callback(err);
+            }
         }
-        return composed;
+    });
+    const onOutputReadable = () => {
+        pumpOutput(composed);
     };
-    // Override pipe to pipe from last transform
-    composed.pipe = function (dest) {
-        return last.pipe(dest);
+    const onOutputEnd = () => {
+        cleanupListeners();
+        outputEnded = true;
+        composed.push(null);
     };
-    // Forward data from last to composed
-    last.on("data", (chunk) => {
-        passthroughWrite(chunk);
-    });
-    // Forward end from last
-    last.on("end", () => {
-        passthroughEnd();
+    const onAnyError = (err) => {
+        cleanupListeners();
+        composed.destroy(err);
+    };
+    const transformErrorListeners = [];
+    const cleanupListeners = () => {
+        output.off("readable", onOutputReadable);
+        output.off("end", onOutputEnd);
+        output.off("error", onAnyError);
+        for (const { t, fn } of transformErrorListeners) {
+            t.off?.("error", fn);
+        }
+        transformErrorListeners.length = 0;
+    };
+    output.on("readable", onOutputReadable);
+    output.once("end", onOutputEnd);
+    output.once("error", onAnyError);
+    for (const t of transforms) {
+        const tt = t;
+        tt.once?.("error", onAnyError);
+        transformErrorListeners.push({ t: tt, fn: onAnyError });
+    }
+    composed.once("close", () => {
+        cleanupListeners();
     });
-    // Forward errors from any transform
-    for (const transform of transforms) {
-        transform.on("error", (err) => {
-            composed.emit("error", err);
-        });
-    }
     return composed;
 }
 /**
@@ -712,7 +794,7 @@ export function once(emitter, event, options) {
                 onAbort();
                 return;
             }
-            options.signal.addEventListener("abort", onAbort);
+            options.signal.addEventListener("abort", onAbort, { once: true });
         }
     });
 }

package/dist/iife/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,81 @@
+# Third-Party Notices
+
+This project includes software developed by third parties. The following notices are provided for attribution and license compliance.
+
+---
+
+## Third-party component
+
+ExcelJS is licensed under the MIT License:
+
+The MIT License (MIT)
+
+Copyright (c) 2014-2019 Guyon Roche
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+## Third-party component
+
+fast-csv is licensed under the MIT License:
+
+The MIT License (MIT)
+
+Copyright (c) 2011-2025 C2FO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+## Third-party component
+
+saxes is licensed under the ISC License:
+
+The ISC License
+
+Copyright (c) Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.