zip-lib 1.3.0 → 1.3.1

package/README.md

@@ -1,5 +1,5 @@
 # zip-lib
-A zip and unzip library for Node.js.
+A zip and unzip library for Node.js with promise-based APIs, support for compressing to `Buffer` or extracting from `Buffer`, and advanced features like entry filtering, cancellation, and symlink-aware handling.
 
 [![npm Package](https://img.shields.io/npm/v/zip-lib.svg)](https://www.npmjs.org/package/zip-lib)
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/fpsqdb/zip-lib/blob/master/LICENSE)
@@ -470,4 +470,4 @@ interface IEntryEvent {
 - `entryCount`: The total number of entries in the archive.
 - `preventDefault()`: Skips the current entry.
 # License
-Licensed under the [MIT](https://github.com/fpsqdb/zip-lib/blob/master/LICENSE) license.
+Licensed under the [MIT](https://github.com/fpsqdb/zip-lib/blob/master/LICENSE) license.

package/lib/unzip.js

@@ -137,9 +137,16 @@ class Unzip extends cancelable_1.Cancelable {
     async extract(zipFileOrBuffer, targetFolder) {
         const token = new cancelable_1.CancellationToken();
         this.token = token;
-        const { zfile, realTargetFolder } = await this.prepareExtraction(zipFileOrBuffer, targetFolder, token);
-        this.zipFile = zfile;
-        await this.processEntries(zfile, targetFolder, realTargetFolder, token);
+        try {
+            const { zfile, realTargetFolder } = await this.prepareExtraction(zipFileOrBuffer, targetFolder, token);
+            this.zipFile = zfile;
+            await this.processEntries(zfile, targetFolder, realTargetFolder, token);
+        }
+        finally {
+            if (this.token === token) {
+                this.token = null;
+            }
+        }
     }
     async prepareExtraction(zipFileOrBuffer, targetFolder, token) {
         if (this.isOverwrite()) {
@@ -162,18 +169,20 @@ class Unzip extends cancelable_1.Cancelable {
             const entryEvent = new EntryEvent(total);
             const settle = this.createPromiseSettler(resolve, reject);
             const disposeCancel = token.onCancelled(() => {
-                this.closeZip();
+                this.closeZip(zfile);
                 settle.reject(this.canceledError());
             });
             zfile.once("error", (err) => {
                 disposeCancel();
                 anyError = this.wrapError(err, token.isCancelled);
-                this.closeZip();
+                this.closeZip(zfile);
                 settle.reject(anyError);
             });
             zfile.once("close", () => {
                 disposeCancel();
-                this.zipFile = null;
+                if (this.zipFile === zfile) {
+                    this.zipFile = null;
+                }
                 if (anyError) {
                     settle.reject(this.wrapError(anyError, token.isCancelled));
                 }
@@ -195,7 +204,7 @@ class Unzip extends cancelable_1.Cancelable {
                 }
                 catch (error) {
                     anyError = this.wrapError(error, token.isCancelled);
-                    this.closeZip();
+                    this.closeZip(zfile);
                     settle.reject(anyError);
                 }
             });
@@ -204,7 +213,7 @@ class Unzip extends cancelable_1.Cancelable {
     }
     readNextEntry(zfile, token) {
         if (token.isCancelled) {
-            this.closeZip();
+            this.closeZip(zfile);
             return;
         }
         zfile.readEntry();
@@ -261,9 +270,12 @@ class Unzip extends cancelable_1.Cancelable {
         }
         this.closeZip();
     }
-    closeZip() {
-        if (this.zipFile) {
-            this.zipFile.close();
+    closeZip(zfile) {
+        const target = zfile !== null && zfile !== void 0 ? zfile : this.zipFile;
+        if (target) {
+            target.close();
+        }
+        if (!zfile || this.zipFile === zfile) {
             this.zipFile = null;
         }
     }

package/lib/zip.d.ts

@@ -28,13 +28,10 @@ export declare class Zip extends Cancelable {
      *
      */
     constructor(options?: IZipOptions | undefined);
-    private yazlFile;
-    private isPipe;
-    private isChunk;
-    private zipStream;
     private zipFiles;
     private zipFolders;
     private token;
+    private activeArchive;
     /**
      * Adds a file from the file system at `realPath` to the zip file as `metadataPath`.
      * @param file

package/lib/zip.js

@@ -17,8 +17,7 @@ class Zip extends cancelable_1.Cancelable {
     constructor(options) {
         super();
         this.options = options;
-        this.isPipe = false;
-        this.isChunk = false;
+        this.activeArchive = null;
         this.zipFiles = [];
         this.zipFolders = [];
     }
@@ -54,62 +53,74 @@ class Zip extends cancelable_1.Cancelable {
         const token = new cancelable_1.CancellationToken();
         this.token = token;
         const zip = await this.prepareArchive(zipFile);
-        return await new Promise((resolve, reject) => {
-            let disposeCancel = () => {
-                // noop
-            };
-            const settle = this.createPromiseSettler((value) => {
-                disposeCancel();
-                resolve(value);
-            }, (error) => {
-                disposeCancel();
-                reject(error);
-            });
-            disposeCancel = token.onCancelled(() => {
-                this.stop(this.canceledError());
-                settle.reject(this.canceledError());
-            });
-            this.bindArchiveOutput(zip, zipFile, token, settle);
-            this.addQueuedEntries(zip, token)
-                .catch((error) => {
-                settle.reject(this.wrapError(error, token.isCancelled));
-            })
-                .finally(() => {
-                zip.end();
+        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);
+                });
+                disposeCancel = token.onCancelled(() => {
+                    this.stop(this.canceledError(), activeArchive);
+                    settle.reject(this.canceledError());
+                });
+                this.bindArchiveOutput(zip, zipFile, token, settle, activeArchive);
+                this.addQueuedEntries(zip, token)
+                    .catch((error) => {
+                    settle.reject(this.wrapError(error, token.isCancelled));
+                })
+                    .finally(() => {
+                    zip.end();
+                });
             });
-        });
+        }
+        finally {
+            if (this.token === token) {
+                this.token = null;
+            }
+            if (this.activeArchive === activeArchive) {
+                this.activeArchive = null;
+            }
+        }
     }
     async prepareArchive(zipFile) {
-        this.isPipe = false;
-        this.isChunk = false;
         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.
-        this.yazlFile = new yazl.ZipFile();
-        return this.yazlFile;
+        return new yazl.ZipFile();
     }
-    bindArchiveOutput(zip, zipFile, token, settle) {
+    bindArchiveOutput(zip, zipFile, token, settle, activeArchive) {
         if (zipFile) {
-            void this.archiveToFile(zip, zipFile, token, settle);
+            void this.archiveToFile(zip, zipFile, token, settle, activeArchive);
             return;
         }
         void this.archiveToBuffer(zip, token, settle);
     }
-    async archiveToFile(zip, zipFile, token, settle) {
-        this.zipStream = (0, node_fs_1.createWriteStream)(zipFile);
-        this.isPipe = true;
+    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();
             });
-            this.zipStream.once("error", (err) => {
+            zipStream.once("error", (err) => {
                 settle.reject(this.wrapError(err, token.isCancelled));
                 resolve();
             });
-            this.zipStream.once("close", () => {
+            zipStream.once("close", () => {
                 if (token.isCancelled) {
                     settle.reject(this.canceledError());
                 }
@@ -119,17 +130,11 @@ class Zip extends cancelable_1.Cancelable {
                 resolve();
             });
         });
-        try {
-            zip.outputStream.pipe(this.zipStream);
-            await archivePromise;
-        }
-        finally {
-            this.isPipe = false;
-        }
+        zip.outputStream.pipe(zipStream);
+        await archivePromise;
     }
     async archiveToBuffer(zip, token, settle) {
         const chunks = [];
-        this.isChunk = true;
         const archivePromise = new Promise((resolve) => {
             zip.once("error", (err) => {
                 settle.reject(this.wrapError(err, token.isCancelled));
@@ -147,12 +152,7 @@ class Zip extends cancelable_1.Cancelable {
                 resolve();
             });
         });
-        try {
-            await archivePromise;
-        }
-        finally {
-            this.isChunk = false;
-        }
+        await archivePromise;
     }
     createPromiseSettler(resolve, reject) {
         let settled = false;
@@ -272,15 +272,20 @@ class Zip extends cancelable_1.Cancelable {
             }
         }
     }
-    stop(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 (this.isChunk) {
-            this.yazlFile.outputStream.destroy(err);
-            this.isChunk = false;
+        if (!activeArchive || this.activeArchive === activeArchive) {
+            this.activeArchive = null;
         }
     }
     followSymlink() {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zip-lib",
-    "version": "1.3.0",
+    "version": "1.3.1",
     "description": "A zip and unzip library for Node.js.",
     "main": "lib/index.js",
     "types": "./lib/index.d.ts",