zip-lib 1.2.3 → 1.3.1

package/lib/zip.js

@@ -17,14 +17,14 @@ class Zip extends cancelable_1.Cancelable {
     constructor(options) {
         super();
         this.options = options;
-        this.isPipe = false;
+        this.activeArchive = null;
         this.zipFiles = [];
         this.zipFolders = [];
     }
     /**
-     * Adds a file from the file system at realPath into the zipfile as metadataPath.
+     * Adds a file from the file system at `realPath` to the zip file as `metadataPath`.
      * @param file
-     * @param metadataPath Typically metadataPath would be calculated as path.relative(root, realPath).
+     * @param metadataPath Typically, `metadataPath` would be calculated as `path.relative(root, realPath)`.
      * A valid metadataPath must not start with "/" or /[A-Za-z]:\//, and must not contain "..".
      */
     addFile(file, metadataPath) {
@@ -38,9 +38,9 @@ class Zip extends cancelable_1.Cancelable {
         });
     }
     /**
-     * Adds a folder from the file system at realPath into the zipfile as metadataPath.
+     * Adds a folder from the file system at `realPath` to the zip file as `metadataPath`.
      * @param folder
-     * @param metadataPath Typically metadataPath would be calculated as path.relative(root, realPath).
+     * @param metadataPath Typically, `metadataPath` would be calculated as `path.relative(root, realPath)`.
      * A valid metadataPath must not start with "/" or /[A-Za-z]:\//, and must not contain "..".
      */
     addFolder(folder, metadataPath) {
@@ -49,64 +49,138 @@ class Zip extends cancelable_1.Cancelable {
             metadataPath,
         });
     }
-    /**
-     * Generate zip file.
-     * @param zipFile the zip file path.
-     */
     async archive(zipFile) {
-        if (!zipFile) {
-            return Promise.reject(new Error("zipPath must not be empty"));
-        }
         const token = new cancelable_1.CancellationToken();
         this.token = token;
-        this.isPipe = false;
-        await exfs.ensureFolder(path.dirname(zipFile));
-        // Re-instantiate yazl every time the archive method is called to ensure that files are not added repeatedly.
-        // This will also make the Zip class reusable.
-        this.yazlFile = new yazl.ZipFile();
-        return new Promise((c, e) => {
-            this.yazlFile.once("error", (err) => {
-                e(this.wrapError(err, token.isCancelled));
-            });
-            const zip = this.yazlFile;
-            if (!token.isCancelled) {
-                this.zipStream = (0, node_fs_1.createWriteStream)(zipFile);
-                this.zipStream.once("error", (err) => {
-                    e(this.wrapError(err, token.isCancelled));
+        const zip = await this.prepareArchive(zipFile);
+        const activeArchive = {
+            zip,
+            mode: zipFile ? "file" : "buffer",
+        };
+        this.activeArchive = activeArchive;
+        try {
+            return await new Promise((resolve, reject) => {
+                let disposeCancel = () => {
+                    // noop
+                };
+                const settle = this.createPromiseSettler((value) => {
+                    disposeCancel();
+                    resolve(value);
+                }, (error) => {
+                    disposeCancel();
+                    reject(error);
                 });
-                this.zipStream.once("close", () => {
-                    if (token.isCancelled) {
-                        e(this.canceledError());
-                    }
-                    else {
-                        c(void 0);
-                    }
+                disposeCancel = token.onCancelled(() => {
+                    this.stop(this.canceledError(), activeArchive);
+                    settle.reject(this.canceledError());
                 });
-                zip.outputStream.once("error", (err) => {
-                    e(this.wrapError(err, token.isCancelled));
+                this.bindArchiveOutput(zip, zipFile, token, settle, activeArchive);
+                this.addQueuedEntries(zip, token)
+                    .catch((error) => {
+                    settle.reject(this.wrapError(error, token.isCancelled));
+                })
+                    .finally(() => {
+                    zip.end();
                 });
-                zip.outputStream.pipe(this.zipStream);
-                this.isPipe = true;
+            });
+        }
+        finally {
+            if (this.token === token) {
+                this.token = null;
             }
-            const start = async () => {
-                try {
-                    const files = this.zipFiles;
-                    for (const file of files) {
-                        const entry = await exfs.getFileEntry(file.path);
-                        await this.addEntry(zip, entry, file, token);
-                    }
-                    if (this.zipFolders.length > 0) {
-                        await this.walkDir(this.zipFolders, token);
-                    }
+            if (this.activeArchive === activeArchive) {
+                this.activeArchive = null;
+            }
+        }
+    }
+    async prepareArchive(zipFile) {
+        if (zipFile) {
+            await exfs.ensureFolder(path.dirname(zipFile));
+        }
+        // Re-instantiate yazl every time the archive method is called to ensure that files are not added repeatedly.
+        // This will also make the Zip class reusable.
+        return new yazl.ZipFile();
+    }
+    bindArchiveOutput(zip, zipFile, token, settle, activeArchive) {
+        if (zipFile) {
+            void this.archiveToFile(zip, zipFile, token, settle, activeArchive);
+            return;
+        }
+        void this.archiveToBuffer(zip, token, settle);
+    }
+    async archiveToFile(zip, zipFile, token, settle, activeArchive) {
+        const zipStream = (0, node_fs_1.createWriteStream)(zipFile);
+        activeArchive.zipStream = zipStream;
+        const archivePromise = new Promise((resolve) => {
+            zip.once("error", (err) => {
+                settle.reject(this.wrapError(err, token.isCancelled));
+                resolve();
+            });
+            zipStream.once("error", (err) => {
+                settle.reject(this.wrapError(err, token.isCancelled));
+                resolve();
+            });
+            zipStream.once("close", () => {
+                if (token.isCancelled) {
+                    settle.reject(this.canceledError());
                 }
-                catch (error) {
-                    e(this.wrapError(error, token.isCancelled));
+                else {
+                    settle.resolve(void 0);
                 }
-            };
-            start().finally(() => {
-                zip.end();
+                resolve();
             });
         });
+        zip.outputStream.pipe(zipStream);
+        await archivePromise;
+    }
+    async archiveToBuffer(zip, token, settle) {
+        const chunks = [];
+        const archivePromise = new Promise((resolve) => {
+            zip.once("error", (err) => {
+                settle.reject(this.wrapError(err, token.isCancelled));
+                resolve();
+            });
+            zip.outputStream.on("data", (chunk) => {
+                chunks.push(chunk);
+            });
+            zip.outputStream.once("end", () => {
+                settle.resolve(Buffer.concat(chunks));
+                resolve();
+            });
+            zip.outputStream.once("error", (err) => {
+                settle.reject(this.wrapError(err, token.isCancelled));
+                resolve();
+            });
+        });
+        await archivePromise;
+    }
+    createPromiseSettler(resolve, reject) {
+        let settled = false;
+        return {
+            resolve: (value) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve(value);
+            },
+            reject: (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                reject(error);
+            },
+        };
+    }
+    async addQueuedEntries(zip, token) {
+        for (const file of this.zipFiles) {
+            const entry = await exfs.getFileEntry(file.path);
+            await this.addEntry(zip, entry, file, token);
+        }
+        if (this.zipFolders.length > 0) {
+            await this.walkDir(zip, this.zipFolders, token);
+        }
     }
     /**
      * Cancel compression.
@@ -117,14 +191,14 @@ class Zip extends cancelable_1.Cancelable {
             this.token.cancel();
             this.token = null;
         }
-        this.stopPipe(this.canceledError());
+        this.stop(this.canceledError());
     }
     async addEntry(zip, entry, file, token) {
         if (entry.isSymbolicLink) {
             if (this.followSymlink()) {
                 if (entry.type === "dir") {
                     const realPath = await exfs.realpath(file.path);
-                    await this.walkDir([{ path: realPath, metadataPath: file.metadataPath }], token);
+                    await this.walkDir(zip, [{ path: realPath, metadataPath: file.metadataPath }], token);
                 }
                 else {
                     zip.addFile(file.path, file.metadataPath, this.getYazlOption());
@@ -147,15 +221,20 @@ class Zip extends cancelable_1.Cancelable {
         }
     }
     addFileStream(zip, file, metadataPath, token) {
-        return new Promise((c, e) => {
+        return new Promise((resolve, reject) => {
             const fileStream = (0, node_fs_1.createReadStream)(file.path);
+            const disposeCancel = token.onCancelled(() => {
+                fileStream.destroy(this.canceledError());
+            });
             fileStream.once("error", (err) => {
+                disposeCancel();
                 const wrappedError = this.wrapError(err, token.isCancelled);
-                this.stopPipe(wrappedError);
-                e(wrappedError);
+                this.stop(wrappedError);
+                reject(wrappedError);
             });
             fileStream.once("close", () => {
-                c();
+                disposeCancel();
+                resolve();
             });
             // If the file attribute is known, add the entry using `addReadStream`,
             // this can reduce the number of calls to the `fs.stat` method.
@@ -166,7 +245,7 @@ class Zip extends cancelable_1.Cancelable {
         const linkTarget = await fs.readlink(file.path);
         zip.addBuffer(Buffer.from(linkTarget), metadataPath, Object.assign(Object.assign({}, this.getYazlOption()), { mtime: file.mtime, mode: file.mode }));
     }
-    async walkDir(folders, token) {
+    async walkDir(zip, folders, token) {
         for (const folder of folders) {
             if (token.isCancelled) {
                 return;
@@ -181,23 +260,32 @@ class Zip extends cancelable_1.Cancelable {
                     const metadataPath = folder.metadataPath
                         ? path.join(folder.metadataPath, relativePath)
                         : relativePath;
-                    await this.addEntry(this.yazlFile, entry, { path: entry.path, metadataPath }, token);
+                    await this.addEntry(zip, entry, { path: entry.path, metadataPath }, token);
                 }
             }
             else {
                 // If the folder is empty and the metadataPath has a value,
                 // an empty folder should be created based on the metadataPath
                 if (folder.metadataPath) {
-                    this.yazlFile.addEmptyDirectory(folder.metadataPath);
+                    zip.addEmptyDirectory(folder.metadataPath);
                 }
             }
         }
     }
-    stopPipe(err) {
-        if (this.isPipe) {
-            this.yazlFile.outputStream.unpipe(this.zipStream);
-            this.zipStream.destroy(err);
-            this.isPipe = false;
+    stop(err, activeArchive) {
+        const archive = activeArchive !== null && activeArchive !== void 0 ? activeArchive : this.activeArchive;
+        if (!archive) {
+            return;
+        }
+        if (archive.mode === "file" && archive.zipStream) {
+            archive.zip.outputStream.unpipe(archive.zipStream);
+            archive.zipStream.destroy(err);
+        }
+        if (archive.mode === "buffer") {
+            archive.zip.outputStream.destroy(err);
+        }
+        if (!activeArchive || this.activeArchive === activeArchive) {
+            this.activeArchive = null;
         }
     }
     followSymlink() {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "zip-lib",
-    "version": "1.2.3",
-    "description": "zip and unzip library for node",
+    "version": "1.3.1",
+    "description": "A zip and unzip library for Node.js.",
     "main": "lib/index.js",
     "types": "./lib/index.d.ts",
     "scripts": {
@@ -34,7 +34,7 @@
         "yazl": "^3.3.1"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.4.7",
+        "@biomejs/biome": "^2.4.8",
         "@types/node": "^20.19.37",
         "@types/yauzl": "^2.10.3",
         "@types/yazl": "^3.3.0",