zip-lib 0.5.0 → 0.7.2

package/README.md

@@ -1,7 +1,7 @@
 # zip-lib
 zip and unzip library for node.
 
-[![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) ![node](https://img.shields.io/node/v/zip-lib) [![Build Status](https://travis-ci.org/fpsqdb/zip-lib.svg?branch=master)](https://travis-ci.org/fpsqdb/zip-lib)
+[![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) ![node](https://img.shields.io/node/v/zip-lib) ![Node.js CI](https://github.com/fpsqdb/zip-lib/workflows/Node.js%20CI/badge.svg)
 
 ## Install
 
@@ -350,11 +350,10 @@ Object
 
 Object
 - `overwrite?`: String (optional) - If it is true, the target directory will be deleted before extract. The default value is `false`.
-- `symlinkAsFileOnWindows?`: Boolean (optional) - Extract symbolic links as files on Windows. This value is only available on Windows and ignored on other platforms. The default value is `true`.
+- `symlinkAsFileOnWindows?`: Boolean (optional) - Extract symbolic links as files on Windows. This value is only available on Windows and ignored on other platforms. The default value is `true`.<br>If `true`, the symlink in the zip will be extracted as a normal file on Windows.<br>If `false`, the symlink in the zip will be extracted as a symlink correctly on Windows, but an `EPERM` error will be thrown under non-administrators.
 
-    > On Windows, the default security policy allows only administrators to create symbolic links.
+    > ⚠**WARNING:** On Windows, the default security policy allows only administrators to create symbolic links. If you set `symlinkAsFileOnWindows` to `false` and the zip contains symlink, be sure to run the code under the administrator, otherwise an `EPERM` error will be thrown.
 
-    If `true`, the symlink in the zip will be extracted as a normal file on Windows.<br>If `false`, the symlink in the zip will be extracted as a symlink correctly on Windows, but an `EPERM` error will be thrown under non-administrators.
 - `onEntry?`: Function (optional) - Called before an item is extracted.<br>Arguments:
     - `event`: Object - Represents an event that an entry is about to be extracted.
         - `entryName`: String (readonly) - Entry name.

package/lib/cancelable.d.ts

@@ -4,13 +4,24 @@ export interface ICancelable {
      */
     cancel(): void;
 }
-export declare abstract class Cancelable implements ICancelable {
+export declare class CancellationToken {
+    private _isCancelled;
+    private _callbacks;
     /**
-     *
+     * A flag signalling is cancellation has been requested.
+     */
+    get isCancelled(): boolean;
+    /**
+     * Subscribe a callback when cancellation is requested. The callback
+     * only ever fires `once` as cancellation can only happen once.
+     * @param cb A function will be called whent cancellation is requested.
+     * @returns A function that Unsubscribe the cancellation callback.
      */
-    constructor();
-    protected isCanceled: boolean;
+    onCancelled(cb: () => void): () => void;
     cancel(): void;
+}
+export declare abstract class Cancelable implements ICancelable {
+    abstract cancel(): void;
     /**
      * Ignore any other error if the `cancel` method has been called
      *
@@ -19,7 +30,7 @@ export declare abstract class Cancelable implements ICancelable {
      * see https://travis-ci.org/fpsqdb/zip-lib/jobs/606040627#L124
      * @param error
      */
-    protected wrapError(error: Error): Error;
+    protected wrapError(error: Error, isCanceled: boolean): Error;
     /**
      * Returns an error that signals cancellation.
      */

package/lib/cancelable.js

@@ -1,15 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-class Cancelable {
+exports.Cancelable = exports.CancellationToken = void 0;
+class CancellationToken {
+    constructor() {
+        this._isCancelled = false;
+        this._callbacks = new Set();
+    }
     /**
-     *
+     * A flag signalling is cancellation has been requested.
      */
-    constructor() {
-        this.isCanceled = false;
+    get isCancelled() {
+        return this._isCancelled;
+    }
+    /**
+     * Subscribe a callback when cancellation is requested. The callback
+     * only ever fires `once` as cancellation can only happen once.
+     * @param cb A function will be called whent cancellation is requested.
+     * @returns A function that Unsubscribe the cancellation callback.
+     */
+    onCancelled(cb) {
+        if (this.isCancelled) {
+            cb();
+            return () => {
+                // noop
+            };
+        }
+        this._callbacks.add(cb);
+        return () => this._callbacks.delete(cb);
     }
     cancel() {
-        this.isCanceled = true;
+        if (this._isCancelled) {
+            return;
+        }
+        this._isCancelled = true;
+        this._callbacks.forEach((cb) => cb());
+        this._callbacks.clear();
     }
+}
+exports.CancellationToken = CancellationToken;
+class Cancelable {
     /**
      * Ignore any other error if the `cancel` method has been called
      *
@@ -18,8 +47,8 @@ class Cancelable {
      * see https://travis-ci.org/fpsqdb/zip-lib/jobs/606040627#L124
      * @param error
      */
-    wrapError(error) {
-        if (this.isCanceled) {
+    wrapError(error, isCanceled) {
+        if (isCanceled) {
             return this.canceledError();
         }
         return error;
@@ -28,10 +57,9 @@ class Cancelable {
      * Returns an error that signals cancellation.
      */
     canceledError() {
-        let error = new Error("Canceled");
+        const error = new Error("Canceled");
         error.name = error.message;
         return error;
     }
 }
 exports.Cancelable = Cancelable;
-//# sourceMappingURL=cancelable.js.map

package/lib/fs.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRootPath = exports.rimraf = exports.pathExists = exports.ensureFolder = exports.getFileEntry = exports.readdirp = void 0;
 const path = require("path");
 const util = require("./util");
 async function readdirp(folder) {
-    let result = [];
+    const result = [];
     const files = await util.readdir(folder);
-    for (let i = 0; i < files.length; i++) {
-        const file = path.join(folder, files[i]);
-        const stat = await util.lstat(file);
-        let fileType = "file";
-        if (stat.isDirectory()) {
-            fileType = "dir";
+    for (const item of files) {
+        const file = path.join(folder, item);
+        const entry = await getFileEntry(file);
+        if (!entry.isSymbolicLink && entry.type === "dir") {
             const subFiles = await readdirp(file);
             if (subFiles.length > 0) {
                 result.push(...subFiles);
@@ -19,21 +18,39 @@ async function readdirp(folder) {
                 continue;
             }
         }
-        else {
-            if (stat.isSymbolicLink()) {
-                fileType = "symlink";
-            }
-        }
-        result.push({
-            path: file,
-            type: fileType,
-            mtime: stat.mtime,
-            mode: stat.mode
-        });
+        result.push(entry);
     }
     return result;
 }
 exports.readdirp = readdirp;
+async function getFileEntry(target) {
+    const stat = await util.lstat(target);
+    let isSymbolicLink = false;
+    let fileType = "file";
+    if (stat.isDirectory()) {
+        fileType = "dir";
+    }
+    else {
+        if (stat.isSymbolicLink()) {
+            isSymbolicLink = true;
+            // If the path is a link, we must instead use fs.stat() to find out if the
+            // link is a directory or not because lstat will always return the stat of
+            // the link which is always a file.
+            const actualStat = await util.stat(target);
+            if (actualStat.isDirectory()) {
+                fileType = "dir";
+            }
+        }
+    }
+    return {
+        path: target,
+        isSymbolicLink,
+        type: fileType,
+        mtime: stat.mtime,
+        mode: stat.mode
+    };
+}
+exports.getFileEntry = getFileEntry;
 async function ensureFolder(folder) {
     // stop at root
     if (folder === path.dirname(folder)) {
@@ -54,9 +71,9 @@ async function ensureFolder(folder) {
     }
 }
 exports.ensureFolder = ensureFolder;
-async function pathExists(path) {
+async function pathExists(target) {
     try {
-        await util.access(path);
+        await util.access(target);
         return true;
     }
     catch (error) {
@@ -101,14 +118,14 @@ async function mkdir(folder) {
         await util.mkdir(folder, 0o777);
     }
     catch (error) {
-        // ENOENT: a parent folder does not exist yet
+        // ENOENT: a parent folder does not exist yet or folder name is invalid.
         if (error.code === "ENOENT") {
             return Promise.reject(error);
         }
         // Any other error: check if folder exists and
         // return normally in that case if its a folder
         try {
-            const fileStat = await util.lstat(folder);
+            const fileStat = await util.stat(folder);
             if (!fileStat.isDirectory()) {
                 return Promise.reject(new Error(`"${folder}" exists and is not a directory.`));
             }
@@ -137,23 +154,22 @@ function isDriveLetter(char0) {
 }
 const winSep = "\\";
 const unixSep = "/";
-function isRootPath(path) {
-    if (!path) {
+function isRootPath(target) {
+    if (!target) {
         return false;
     }
-    if (path === winSep ||
-        path === unixSep) {
+    if (target === winSep ||
+        target === unixSep) {
         return true;
     }
     if (process.platform === "win32") {
-        if (path.length > 3) {
+        if (target.length > 3) {
             return false;
         }
-        return isDriveLetter(path.charCodeAt(0))
-            && path.charCodeAt(1) === charColon
-            && (path.length === 2 || path.charCodeAt(2) === charWinSep || path.charCodeAt(2) === cahrUnixSep);
+        return isDriveLetter(target.charCodeAt(0))
+            && target.charCodeAt(1) === charColon
+            && (target.length === 2 || target.charCodeAt(2) === charWinSep || target.charCodeAt(2) === cahrUnixSep);
     }
     return false;
 }
 exports.isRootPath = isRootPath;
-//# sourceMappingURL=fs.js.map

package/lib/index.js

@@ -1,12 +1,20 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extract = exports.archiveFolder = exports.archiveFile = void 0;
 const zip_1 = require("./zip");
 const unzip_1 = require("./unzip");
-__export(require("./zip"));
-__export(require("./unzip"));
+__exportStar(require("./zip"), exports);
+__exportStar(require("./unzip"), exports);
 /**
  * Compress a single file to zip.
  * @param file
@@ -42,4 +50,3 @@ function extract(zipFile, targetFolder, options) {
     return unzip.extract(zipFile, targetFolder);
 }
 exports.extract = extract;
-//# sourceMappingURL=index.js.map

package/lib/unzip.d.ts

@@ -9,11 +9,13 @@ export interface IExtractOptions {
      * Extract symbolic links as files on Windows. This value is only available on Windows and ignored on other platforms.
      * The default value is `true`.
      *
-     * > On Windows, the default security policy allows only administrators to create symbolic links.
-     *
      * If `true`, the symlink in the zip will be extracted as a normal file on Windows.
      *
      * If `false`, the symlink in the zip will be extracted as a symlink correctly on Windows, but an `EPERM` error will be thrown under non-administrators.
+     *
+     * > ⚠**WARNING:** On Windows, the default security policy allows only administrators to create symbolic links.
+     * If you set `symlinkAsFileOnWindows` to `false` and the zip contains symlink,
+     * be sure to run the code under the administrator, otherwise an `EPERM` error will be thrown.
      */
     symlinkAsFileOnWindows?: boolean;
     /**
@@ -49,7 +51,7 @@ export declare class Unzip extends Cancelable {
      */
     constructor(options?: IExtractOptions | undefined);
     private zipFile;
-    private cancelCallback?;
+    private token;
     /**
      * Extract the zip file to the specified location.
      * @param zipFile

package/lib/unzip.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unzip = void 0;
 const yauzl = require("yauzl");
 const exfs = require("./fs");
 const fs_1 = require("fs");
@@ -33,6 +34,50 @@ class EntryEvent {
         this._isPrevented = false;
     }
 }
+class EntryContext {
+    constructor(_targetFolder, _realTargetFolder, symlinkAsFileOnWindows) {
+        this._targetFolder = _targetFolder;
+        this._realTargetFolder = _realTargetFolder;
+        this.symlinkAsFileOnWindows = symlinkAsFileOnWindows;
+        this._symlinkFileNames = [];
+    }
+    get decodeEntryFileName() {
+        return this._decodeEntryFileName;
+    }
+    set decodeEntryFileName(name) {
+        this._decodeEntryFileName = name;
+    }
+    get targetFolder() {
+        return this._targetFolder;
+    }
+    get realTargetFolder() {
+        return this._realTargetFolder;
+    }
+    get symlinkFileNames() {
+        return this._symlinkFileNames;
+    }
+    getFilePath() {
+        return path.join(this.targetFolder, this.decodeEntryFileName);
+    }
+    async isOutsideTargetFolder(tpath) {
+        if (this.symlinkFileNames.length === 0) {
+            return false;
+        }
+        if (process.platform === "win32" &&
+            this.symlinkAsFileOnWindows) {
+            return false;
+        }
+        for (const fileName of this.symlinkFileNames) {
+            if (tpath.includes(fileName)) {
+                const realFilePath = await util.realpath(tpath);
+                if (realFilePath.indexOf(this.realTargetFolder) !== 0) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
 /**
  * Extract the zip file.
  */
@@ -52,37 +97,48 @@ class Unzip extends cancelable_1.Cancelable {
      */
     async extract(zipFile, targetFolder) {
         let extractedEntriesCount = 0;
-        this.isCanceled = false;
+        const token = new cancelable_1.CancellationToken();
+        this.token = token;
         if (this.isOverwrite()) {
             await exfs.rimraf(targetFolder);
         }
-        if (this.isCanceled) {
+        if (token.isCancelled) {
             return Promise.reject(this.canceledError());
         }
         await exfs.ensureFolder(targetFolder);
-        const zfile = await this.openZip(zipFile);
+        const realTargetFolder = await util.realpath(targetFolder);
+        const zfile = await this.openZip(zipFile, token);
         this.zipFile = zfile;
         zfile.readEntry();
         return new Promise((c, e) => {
+            let anyError = null;
             const total = zfile.entryCount;
             zfile.once("error", (err) => {
-                e(this.wrapError(err));
+                this.closeZip();
+                e(this.wrapError(err, token.isCancelled));
             });
             zfile.once("close", () => {
-                if (this.isCanceled) {
-                    e(this.canceledError());
+                this.zipFile = null;
+                if (anyError) {
+                    e(this.wrapError(anyError, token.isCancelled));
                 }
-                // If the zip content is empty, it will not receive the `zfile.on("entry")` event.
-                else if (total === 0) {
-                    c(void 0);
+                else {
+                    if (token.isCancelled) {
+                        e(this.canceledError());
+                    }
+                    // If the zip content is empty, it will not receive the `zfile.on("entry")` event.
+                    else if (total === 0) {
+                        c(void 0);
+                    }
                 }
             });
             // Because openZip is an asynchronous method, openZip may not be completed when calling cancel,
             // so we need to check if it has been canceled after the openZip method returns.
-            if (this.isCanceled) {
+            if (token.isCancelled) {
                 this.closeZip();
                 return;
             }
+            const entryContext = new EntryContext(targetFolder, realTargetFolder, this.symlinkToFile());
             const entryEvent = new EntryEvent(total);
             zfile.on("entry", async (entry) => {
                 // use UTF-8 in all situations
@@ -94,19 +150,21 @@ class Unzip extends cancelable_1.Cancelable {
                 // see https://github.com/thejoshwolfe/yauzl#validatefilenamefilename
                 const errorMessage = yauzl.validateFileName(fileName);
                 if (errorMessage != null) {
-                    e(new Error(errorMessage));
+                    anyError = new Error(errorMessage);
                     this.closeZip();
+                    e(anyError);
                     return;
                 }
                 entryEvent.entryName = fileName;
                 this.onEntryCallback(entryEvent);
+                entryContext.decodeEntryFileName = fileName;
                 try {
                     if (entryEvent.isPrevented) {
                         entryEvent.reset();
                         zfile.readEntry();
                     }
                     else {
-                        await this.handleEntry(zfile, entry, fileName, targetFolder);
+                        await this.handleEntry(zfile, entry, entryContext, token);
                     }
                     extractedEntriesCount++;
                     if (extractedEntriesCount === total) {
@@ -114,8 +172,9 @@ class Unzip extends cancelable_1.Cancelable {
                     }
                 }
                 catch (error) {
-                    e(this.wrapError(error));
+                    anyError = this.wrapError(error, token.isCancelled);
                     this.closeZip();
+                    e(anyError);
                 }
             });
         });
@@ -125,9 +184,9 @@ class Unzip extends cancelable_1.Cancelable {
      * If the cancel method is called after the extract is complete, nothing will happen.
      */
     cancel() {
-        super.cancel();
-        if (this.cancelCallback) {
-            this.cancelCallback(this.canceledError());
+        if (this.token) {
+            this.token.cancel();
+            this.token = null;
         }
         this.closeZip();
     }
@@ -137,7 +196,7 @@ class Unzip extends cancelable_1.Cancelable {
             this.zipFile = null;
         }
     }
-    openZip(zipFile) {
+    openZip(zipFile, token) {
         return new Promise((c, e) => {
             yauzl.open(zipFile, {
                 lazyEntries: true,
@@ -145,7 +204,7 @@ class Unzip extends cancelable_1.Cancelable {
                 decodeStrings: false
             }, (err, zfile) => {
                 if (err) {
-                    e(this.wrapError(err));
+                    e(this.wrapError(err, token.isCancelled));
                 }
                 else {
                     c(zfile);
@@ -153,24 +212,24 @@ class Unzip extends cancelable_1.Cancelable {
             });
         });
     }
-    async handleEntry(zfile, entry, decodeEntryFileName, targetPath) {
-        if (/\/$/.test(decodeEntryFileName)) {
+    async handleEntry(zfile, entry, entryContext, token) {
+        if (/\/$/.test(entryContext.decodeEntryFileName)) {
             // Directory file names end with '/'.
             // Note that entires for directories themselves are optional.
             // An entry's fileName implicitly requires its parent directories to exist.
-            await exfs.ensureFolder(path.join(targetPath, decodeEntryFileName));
+            await exfs.ensureFolder(entryContext.getFilePath());
             zfile.readEntry();
         }
         else {
             // file entry
-            await this.extractEntry(zfile, entry, decodeEntryFileName, targetPath);
+            await this.extractEntry(zfile, entry, entryContext, token);
         }
     }
-    openZipFileStream(zfile, entry) {
+    openZipFileStream(zfile, entry, token) {
         return new Promise((c, e) => {
             zfile.openReadStream(entry, (err, readStream) => {
                 if (err) {
-                    e(this.wrapError(err));
+                    e(this.wrapError(err, token.isCancelled));
                 }
                 else {
                     c(readStream);
@@ -178,32 +237,40 @@ class Unzip extends cancelable_1.Cancelable {
             });
         });
     }
-    async extractEntry(zfile, entry, decodeEntryFileName, targetPath) {
-        const filePath = path.join(targetPath, decodeEntryFileName);
-        await exfs.ensureFolder(path.dirname(filePath));
-        const readStream = await this.openZipFileStream(zfile, entry);
-        readStream.on("end", () => {
-            zfile.readEntry();
-        });
-        await this.writeEntryToFile(readStream, entry, filePath);
+    async extractEntry(zfile, entry, entryContext, token) {
+        const filePath = entryContext.getFilePath();
+        const fileDir = path.dirname(filePath);
+        await exfs.ensureFolder(fileDir);
+        const outside = await entryContext.isOutsideTargetFolder(fileDir);
+        if (outside) {
+            const error = new Error(`Refuse to write file outside "${entryContext.targetFolder}", file: "${filePath}"`);
+            error.name = "AFWRITE";
+            return Promise.reject(error);
+        }
+        const readStream = await this.openZipFileStream(zfile, entry, token);
+        await this.writeEntryToFile(readStream, entry, entryContext, token);
+        zfile.readEntry();
     }
-    async writeEntryToFile(readStream, entry, filePath) {
+    async writeEntryToFile(readStream, entry, entryContext, token) {
         let fileStream;
-        this.cancelCallback = (err) => {
-            this.cancelCallback = undefined;
+        token.onCancelled(() => {
             if (fileStream) {
                 readStream.unpipe(fileStream);
-                fileStream.destroy(err);
+                fileStream.destroy(this.canceledError());
             }
-        };
+        });
         return new Promise(async (c, e) => {
             try {
+                const filePath = entryContext.getFilePath();
                 const mode = this.modeFromEntry(entry);
                 // see https://unix.stackexchange.com/questions/193465/what-file-mode-is-a-symlink
                 const isSymlink = ((mode & 0o170000) === 0o120000);
                 readStream.once("error", (err) => {
-                    e(this.wrapError(err));
+                    e(this.wrapError(err, token.isCancelled));
                 });
+                if (isSymlink) {
+                    entryContext.symlinkFileNames.push(entryContext.decodeEntryFileName);
+                }
                 if (isSymlink && !this.symlinkToFile()) {
                     let linkContent = "";
                     readStream.on("data", (chunk) => {
@@ -222,13 +289,13 @@ class Unzip extends cancelable_1.Cancelable {
                     fileStream = fs_1.createWriteStream(filePath, { mode });
                     fileStream.once("close", () => c());
                     fileStream.once("error", (err) => {
-                        e(this.wrapError(err));
+                        e(this.wrapError(err, token.isCancelled));
                     });
                     readStream.pipe(fileStream);
                 }
             }
             catch (error) {
-                e(this.wrapError(error));
+                e(this.wrapError(error, token.isCancelled));
             }
         });
     }
@@ -239,7 +306,28 @@ class Unzip extends cancelable_1.Cancelable {
             .reduce((a, b) => a + b, attr & 61440 /* S_IFMT */);
     }
     async createSymlink(linkContent, des) {
-        await util.symlink(linkContent, des);
+        let linkType = "file";
+        if (process.platform === 'win32') {
+            if (/\/$/.test(linkContent)) {
+                linkType = "dir";
+            }
+            else {
+                let targetPath = linkContent;
+                if (!path.isAbsolute(linkContent)) {
+                    targetPath = path.join(path.dirname(des), linkContent);
+                }
+                try {
+                    const stat = await util.stat(targetPath);
+                    if (stat.isDirectory()) {
+                        linkType = "dir";
+                    }
+                }
+                catch (error) {
+                    // ignore
+                }
+            }
+        }
+        await util.symlink(linkContent, des, linkType);
     }
     isOverwrite() {
         if (this.options &&
@@ -268,4 +356,3 @@ class Unzip extends cancelable_1.Cancelable {
     }
 }
 exports.Unzip = Unzip;
-//# sourceMappingURL=unzip.js.map

package/lib/util.js

@@ -1,89 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readlink = exports.symlink = exports.rmdir = exports.access = exports.readdir = exports.chmod = exports.lstat = exports.stat = exports.realpath = exports.mkdir = exports.unlink = void 0;
 const fs = require("fs");
 const util = require("util");
-function asyncCall(fn, ...args) {
-    return new Promise((c, e) => fn(...args, (err, result) => err ? e(err) : c(result)));
-}
 function unlink(path) {
-    if (typeof util.promisify === "function") {
-        return util.promisify(fs.unlink)(path);
-    }
-    else {
-        return asyncCall(fs.unlink, path);
-    }
+    return util.promisify(fs.unlink)(path);
 }
 exports.unlink = unlink;
 function mkdir(path, mode) {
-    if (typeof util.promisify === "function") {
-        return util.promisify(fs.mkdir)(path, mode);
-    }
-    else {
-        return asyncCall(fs.mkdir, path, mode);
-    }
+    return util.promisify(fs.mkdir)(path, mode);
 }
 exports.mkdir = mkdir;
+function realpath(path) {
+    return util.promisify(fs.realpath)(path);
+}
+exports.realpath = realpath;
+function stat(path) {
+    return util.promisify(fs.stat)(path);
+}
+exports.stat = stat;
 function lstat(path) {
-    if (typeof util.promisify === "function") {
-        return util.promisify(fs.lstat)(path);
-    }
-    else {
-        return asyncCall(fs.lstat, path);
-    }
+    return util.promisify(fs.lstat)(path);
 }
 exports.lstat = lstat;
 function chmod(path, mode) {
-    if (typeof util.promisify === "function") {
-        return util.promisify(fs.chmod)(path, mode);
-    }
-    else {
-        return asyncCall(fs.chmod, path, mode);
-    }
+    return util.promisify(fs.chmod)(path, mode);
 }
 exports.chmod = chmod;
 function readdir(path) {
-    if (typeof util.promisify === "function") {
-        return util.promisify(fs.readdir)(path);
-    }
-    else {
-        return asyncCall(fs.readdir, path);
-    }
+    return util.promisify(fs.readdir)(path);
 }
 exports.readdir = readdir;
 function access(path, mode) {
-    if (typeof util.promisify === "function") {
-        return util.promisify(fs.access)(path, mode);
-    }
-    else {
-        return asyncCall(fs.access, path, mode);
-    }
+    return util.promisify(fs.access)(path, mode);
 }
 exports.access = access;
 function rmdir(path) {
-    if (typeof util.promisify === "function") {
-        return util.promisify(fs.rmdir)(path);
-    }
-    else {
-        return asyncCall(fs.rmdir, path);
-    }
+    return util.promisify(fs.rmdir)(path);
 }
 exports.rmdir = rmdir;
-function symlink(target, path) {
-    if (typeof util.promisify === "function") {
-        return util.promisify(fs.symlink)(target, path);
-    }
-    else {
-        return asyncCall(fs.symlink, target, path);
-    }
+function symlink(target, path, type) {
+    return util.promisify(fs.symlink)(target, path, type);
 }
 exports.symlink = symlink;
 function readlink(path) {
-    if (typeof util.promisify === "function") {
-        return util.promisify(fs.readlink)(path);
-    }
-    else {
-        return asyncCall(fs.readlink, path);
-    }
+    return util.promisify(fs.readlink)(path);
 }
 exports.readlink = readlink;
-//# sourceMappingURL=util.js.map

package/lib/zip.d.ts

@@ -25,7 +25,7 @@ export declare class Zip extends Cancelable {
     private zipStream;
     private zipFiles;
     private zipFolders;
-    private yazlErrorCallback?;
+    private token;
     /**
      * Adds a file from the file system at realPath into the zipfile as metadataPath.
      * @param file
@@ -50,8 +50,8 @@ export declare class Zip extends Cancelable {
      * If the cancel method is called after the archive is complete, nothing will happen.
      */
     cancel(): void;
-    private initYazl;
-    private addFileOrSymlink;
+    private addEntry;
+    private addFileStream;
     private addSymlink;
     private walkDir;
     private stopPipe;

package/lib/zip.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Zip = void 0;
 const yazl = require("yazl");
 const fs_1 = require("fs");
 const exfs = require("./fs");
@@ -45,7 +46,7 @@ class Zip extends cancelable_1.Cancelable {
     addFolder(folder, metadataPath) {
         this.zipFolders.push({
             path: folder,
-            metadataPath: metadataPath
+            metadataPath
         });
     }
     /**
@@ -56,40 +57,25 @@ class Zip extends cancelable_1.Cancelable {
         if (!zipFile) {
             return Promise.reject(new Error("zipPath must not be empty"));
         }
-        this.isCanceled = false;
+        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.initYazl();
+        this.yazlFile = new yazl.ZipFile();
         return new Promise(async (c, e) => {
-            this.yazlErrorCallback = (err) => {
-                this.yazlErrorCallback = undefined;
-                e(err);
-            };
+            this.yazlFile.once("error", (err) => {
+                e(this.wrapError(err, token.isCancelled));
+            });
             const zip = this.yazlFile;
-            try {
-                const files = this.zipFiles;
-                for (let fi = 0; fi < files.length; fi++) {
-                    const file = files[fi];
-                    await this.addFileOrSymlink(zip, file.path, file.metadataPath);
-                }
-                if (this.zipFolders.length > 0) {
-                    await this.walkDir(this.zipFolders);
-                }
-                await exfs.ensureFolder(path.dirname(zipFile));
-            }
-            catch (error) {
-                e(this.wrapError(error));
-                return;
-            }
-            zip.end();
-            if (!this.isCanceled) {
+            if (!token.isCancelled) {
                 this.zipStream = fs_1.createWriteStream(zipFile);
                 this.zipStream.once("error", (err) => {
-                    e(this.wrapError(err));
+                    e(this.wrapError(err, token.isCancelled));
                 });
                 this.zipStream.once("close", () => {
-                    if (this.isCanceled) {
+                    if (token.isCancelled) {
                         e(this.canceledError());
                     }
                     else {
@@ -97,11 +83,26 @@ class Zip extends cancelable_1.Cancelable {
                     }
                 });
                 zip.outputStream.once("error", (err) => {
-                    e(this.wrapError(err));
+                    e(this.wrapError(err, token.isCancelled));
                 });
                 zip.outputStream.pipe(this.zipStream);
                 this.isPipe = true;
             }
+            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);
+                }
+            }
+            catch (error) {
+                e(this.wrapError(error, token.isCancelled));
+                return;
+            }
+            zip.end();
         });
     }
     /**
@@ -109,34 +110,58 @@ class Zip extends cancelable_1.Cancelable {
      * If the cancel method is called after the archive is complete, nothing will happen.
      */
     cancel() {
-        super.cancel();
+        if (this.token) {
+            this.token.cancel();
+            this.token = null;
+        }
         this.stopPipe(this.canceledError());
     }
-    initYazl() {
-        this.yazlFile = new yazl.ZipFile();
-        this.yazlFile.once("error", (err) => {
-            this.stopPipe(this.wrapError(err));
-        });
-    }
-    async addFileOrSymlink(zip, file, metadataPath) {
-        if (this.followSymlink()) {
-            zip.addFile(file, metadataPath);
+    async addEntry(zip, entry, file, token) {
+        if (entry.isSymbolicLink) {
+            if (this.followSymlink()) {
+                if (entry.type === "dir") {
+                    const realPath = await util.realpath(file.path);
+                    await this.walkDir([{ path: realPath, metadataPath: file.metadataPath }], token);
+                }
+                else {
+                    zip.addFile(file.path, file.metadataPath);
+                }
+            }
+            else {
+                await this.addSymlink(zip, entry, file.metadataPath);
+            }
         }
         else {
-            const stat = await util.lstat(file);
-            if (stat.isSymbolicLink()) {
-                await this.addSymlink(zip, {
-                    path: file,
-                    type: "file",
-                    mtime: stat.mtime,
-                    mode: stat.mode
-                }, metadataPath);
+            if (entry.type === "dir") {
+                zip.addEmptyDirectory(file.metadataPath, {
+                    mtime: entry.mtime,
+                    mode: entry.mode
+                });
             }
             else {
-                zip.addFile(file, metadataPath);
+                await this.addFileStream(zip, entry, file.metadataPath, token);
             }
         }
     }
+    addFileStream(zip, file, metadataPath, token) {
+        return new Promise((c, e) => {
+            const fileStream = fs_1.createReadStream(file.path);
+            fileStream.once("error", (err) => {
+                const wrappedError = this.wrapError(err, token.isCancelled);
+                this.stopPipe(wrappedError);
+                e(wrappedError);
+            });
+            fileStream.once("close", () => {
+                c();
+            });
+            // If the file attribute is known, add the entry using `addReadStream`,
+            // this can reduce the number of calls to the `fs.stat` method.
+            zip.addReadStream(fileStream, metadataPath, {
+                mode: file.mode,
+                mtime: file.mtime
+            });
+        });
+    }
     async addSymlink(zip, file, metadataPath) {
         const linkTarget = await util.readlink(file.path);
         zip.addBuffer(Buffer.from(linkTarget), metadataPath, {
@@ -144,33 +169,20 @@ class Zip extends cancelable_1.Cancelable {
             mode: file.mode
         });
     }
-    async walkDir(folders) {
-        for (let fi = 0; fi < folders.length; fi++) {
-            if (this.isCanceled) {
+    async walkDir(folders, token) {
+        for (const folder of folders) {
+            if (token.isCancelled) {
                 return;
             }
-            const folder = folders[fi];
             const entries = await exfs.readdirp(folder.path);
             if (entries.length > 0) {
-                for (let ei = 0; ei < entries.length; ei++) {
-                    const entry = entries[ei];
-                    if (this.isCanceled) {
+                for (const entry of entries) {
+                    if (token.isCancelled) {
                         return;
                     }
                     const relativePath = path.relative(folder.path, entry.path);
                     const metadataPath = folder.metadataPath ? path.join(folder.metadataPath, relativePath) : relativePath;
-                    if (entry.type === "dir") {
-                        this.yazlFile.addEmptyDirectory(metadataPath, {
-                            mtime: entry.mtime,
-                            mode: entry.mode
-                        });
-                    }
-                    else if (entry.type === "symlink" && !this.followSymlink()) {
-                        await this.addSymlink(this.yazlFile, entry, metadataPath);
-                    }
-                    else {
-                        this.yazlFile.addFile(entry.path, metadataPath);
-                    }
+                    await this.addEntry(this.yazlFile, entry, { path: entry.path, metadataPath }, token);
                 }
             }
             else {
@@ -183,9 +195,6 @@ class Zip extends cancelable_1.Cancelable {
         }
     }
     stopPipe(err) {
-        if (this.yazlErrorCallback) {
-            this.yazlErrorCallback(err);
-        }
         if (this.isPipe) {
             this.yazlFile.outputStream.unpipe(this.zipStream);
             this.zipStream.destroy(err);
@@ -202,4 +211,3 @@ class Zip extends cancelable_1.Cancelable {
     }
 }
 exports.Zip = Zip;
-//# sourceMappingURL=zip.js.map

package/package.json

@@ -1,12 +1,14 @@
 {
     "name": "zip-lib",
-    "version": "0.5.0",
+    "version": "0.7.2",
     "description": "zip and unzip library for node",
     "main": "lib/index.js",
     "scripts": {
         "compile": "rimraf ./lib && tsc -p ./src/tsconfig.json",
+        "release": "rimraf ./lib && tsc -p ./src/tsconfig.release.json",
         "compile-test": "rimraf ./test/out && tsc -p ./test/src/tsconfig.json",
-        "test": "node ./test/src/before.js && mocha ./test/out --timeout 5000"
+        "test": "node ./test/src/before.js && mocha ./test/out --timeout 10000",
+        "pack": "npm run release && npm pack"
     },
     "repository": {
         "type": "git",
@@ -28,12 +30,12 @@
         "yazl": "^2.5.1"
     },
     "devDependencies": {
-        "@types/mocha": "^5.2.7",
-        "@types/node": "^8.10.56",
+        "@types/mocha": "^8.2.0",
+        "@types/node": "^8.10.66",
         "@types/yauzl": "^2.9.1",
         "@types/yazl": "^2.4.2",
-        "mocha": "^6.2.2",
-        "rimraf": "^3.0.0",
-        "typescript": "^3.6.4"
+        "mocha": "^8.2.1",
+        "rimraf": "^3.0.2",
+        "typescript": "^4.1.3"
     }
 }