zip-lib 0.7.2 → 1.0.0

package/lib/util.js

@@ -1,49 +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 unlink(path) {
-    return util.promisify(fs.unlink)(path);
-}
-exports.unlink = unlink;
-function 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) {
-    return util.promisify(fs.lstat)(path);
-}
-exports.lstat = lstat;
-function chmod(path, mode) {
-    return util.promisify(fs.chmod)(path, mode);
-}
-exports.chmod = chmod;
-function readdir(path) {
-    return util.promisify(fs.readdir)(path);
-}
-exports.readdir = readdir;
-function access(path, mode) {
-    return util.promisify(fs.access)(path, mode);
-}
-exports.access = access;
-function rmdir(path) {
-    return util.promisify(fs.rmdir)(path);
-}
-exports.rmdir = rmdir;
-function symlink(target, path, type) {
-    return util.promisify(fs.symlink)(target, path, type);
-}
-exports.symlink = symlink;
-function readlink(path) {
-    return util.promisify(fs.readlink)(path);
-}
-exports.readlink = readlink;
+"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 unlink(path) {
+    return util.promisify(fs.unlink)(path);
+}
+exports.unlink = unlink;
+function 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) {
+    return util.promisify(fs.lstat)(path);
+}
+exports.lstat = lstat;
+function chmod(path, mode) {
+    return util.promisify(fs.chmod)(path, mode);
+}
+exports.chmod = chmod;
+function readdir(path) {
+    return util.promisify(fs.readdir)(path);
+}
+exports.readdir = readdir;
+function access(path, mode) {
+    return util.promisify(fs.access)(path, mode);
+}
+exports.access = access;
+function rmdir(path) {
+    return util.promisify(fs.rmdir)(path);
+}
+exports.rmdir = rmdir;
+function symlink(target, path, type) {
+    return util.promisify(fs.symlink)(target, path, type);
+}
+exports.symlink = symlink;
+function readlink(path) {
+    return util.promisify(fs.readlink)(path);
+}
+exports.readlink = readlink;

package/lib/zip.d.ts

@@ -1,59 +1,59 @@
-import { Cancelable } from "./cancelable";
-export interface IZipOptions {
-    /**
-     * Indicates how to handle when the given path is a symbolic link.
-     *
-     * `true`: add the target of the symbolic link to the zip.
-     *
-     * `false`: add symbolic link itself to the zip.
-     *
-     * The default value is `false`.
-     */
-    followSymlinks?: boolean;
-}
-/**
- * Compress files or folders to a zip file.
- */
-export declare class Zip extends Cancelable {
-    private options?;
-    /**
-     *
-     */
-    constructor(options?: IZipOptions | undefined);
-    private yazlFile;
-    private isPipe;
-    private zipStream;
-    private zipFiles;
-    private zipFolders;
-    private token;
-    /**
-     * Adds a file from the file system at realPath into the zipfile as metadataPath.
-     * @param file
-     * @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: string, metadataPath?: string): void;
-    /**
-     * Adds a folder from the file system at realPath into the zipfile as metadataPath.
-     * @param folder
-     * @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: string, metadataPath?: string): void;
-    /**
-     * Generate zip file.
-     * @param zipFile the zip file path.
-     */
-    archive(zipFile: string): Promise<void>;
-    /**
-     * Cancel compression.
-     * If the cancel method is called after the archive is complete, nothing will happen.
-     */
-    cancel(): void;
-    private addEntry;
-    private addFileStream;
-    private addSymlink;
-    private walkDir;
-    private stopPipe;
-    private followSymlink;
-}
+import { Cancelable } from "./cancelable";
+export interface IZipOptions {
+    /**
+     * Indicates how to handle when the given path is a symbolic link.
+     *
+     * `true`: add the target of the symbolic link to the zip.
+     *
+     * `false`: add symbolic link itself to the zip.
+     *
+     * The default value is `false`.
+     */
+    followSymlinks?: boolean;
+}
+/**
+ * Compress files or folders to a zip file.
+ */
+export declare class Zip extends Cancelable {
+    private options?;
+    /**
+     *
+     */
+    constructor(options?: IZipOptions | undefined);
+    private yazlFile;
+    private isPipe;
+    private zipStream;
+    private zipFiles;
+    private zipFolders;
+    private token;
+    /**
+     * Adds a file from the file system at realPath into the zipfile as metadataPath.
+     * @param file
+     * @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: string, metadataPath?: string): void;
+    /**
+     * Adds a folder from the file system at realPath into the zipfile as metadataPath.
+     * @param folder
+     * @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: string, metadataPath?: string): void;
+    /**
+     * Generate zip file.
+     * @param zipFile the zip file path.
+     */
+    archive(zipFile: string): Promise<void>;
+    /**
+     * Cancel compression.
+     * If the cancel method is called after the archive is complete, nothing will happen.
+     */
+    cancel(): void;
+    private addEntry;
+    private addFileStream;
+    private addSymlink;
+    private walkDir;
+    private stopPipe;
+    private followSymlink;
+}

package/lib/zip.js

@@ -1,213 +1,213 @@
-"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");
-const path = require("path");
-const util = require("./util");
-const cancelable_1 = require("./cancelable");
-/**
- * Compress files or folders to a zip file.
- */
-class Zip extends cancelable_1.Cancelable {
-    /**
-     *
-     */
-    constructor(options) {
-        super();
-        this.options = options;
-        this.isPipe = false;
-        this.zipFiles = [];
-        this.zipFolders = [];
-    }
-    /**
-     * Adds a file from the file system at realPath into the zipfile as metadataPath.
-     * @param file
-     * @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) {
-        let mpath = metadataPath;
-        if (!mpath) {
-            mpath = path.basename(file);
-        }
-        this.zipFiles.push({
-            path: file,
-            metadataPath: mpath
-        });
-    }
-    /**
-     * Adds a folder from the file system at realPath into the zipfile as metadataPath.
-     * @param folder
-     * @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) {
-        this.zipFolders.push({
-            path: folder,
-            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(async (c, e) => {
-            this.yazlFile.once("error", (err) => {
-                e(this.wrapError(err, token.isCancelled));
-            });
-            const zip = this.yazlFile;
-            if (!token.isCancelled) {
-                this.zipStream = fs_1.createWriteStream(zipFile);
-                this.zipStream.once("error", (err) => {
-                    e(this.wrapError(err, token.isCancelled));
-                });
-                this.zipStream.once("close", () => {
-                    if (token.isCancelled) {
-                        e(this.canceledError());
-                    }
-                    else {
-                        c(void 0);
-                    }
-                });
-                zip.outputStream.once("error", (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();
-        });
-    }
-    /**
-     * Cancel compression.
-     * If the cancel method is called after the archive is complete, nothing will happen.
-     */
-    cancel() {
-        if (this.token) {
-            this.token.cancel();
-            this.token = null;
-        }
-        this.stopPipe(this.canceledError());
-    }
-    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 {
-            if (entry.type === "dir") {
-                zip.addEmptyDirectory(file.metadataPath, {
-                    mtime: entry.mtime,
-                    mode: entry.mode
-                });
-            }
-            else {
-                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, {
-            mtime: file.mtime,
-            mode: file.mode
-        });
-    }
-    async walkDir(folders, token) {
-        for (const folder of folders) {
-            if (token.isCancelled) {
-                return;
-            }
-            const entries = await exfs.readdirp(folder.path);
-            if (entries.length > 0) {
-                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;
-                    await this.addEntry(this.yazlFile, 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);
-                }
-            }
-        }
-    }
-    stopPipe(err) {
-        if (this.isPipe) {
-            this.yazlFile.outputStream.unpipe(this.zipStream);
-            this.zipStream.destroy(err);
-            this.isPipe = false;
-        }
-    }
-    followSymlink() {
-        let followSymlink = false;
-        if (this.options &&
-            this.options.followSymlinks === true) {
-            followSymlink = true;
-        }
-        return followSymlink;
-    }
-}
-exports.Zip = Zip;
+"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");
+const path = require("path");
+const util = require("./util");
+const cancelable_1 = require("./cancelable");
+/**
+ * Compress files or folders to a zip file.
+ */
+class Zip extends cancelable_1.Cancelable {
+    /**
+     *
+     */
+    constructor(options) {
+        super();
+        this.options = options;
+        this.isPipe = false;
+        this.zipFiles = [];
+        this.zipFolders = [];
+    }
+    /**
+     * Adds a file from the file system at realPath into the zipfile as metadataPath.
+     * @param file
+     * @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) {
+        let mpath = metadataPath;
+        if (!mpath) {
+            mpath = path.basename(file);
+        }
+        this.zipFiles.push({
+            path: file,
+            metadataPath: mpath
+        });
+    }
+    /**
+     * Adds a folder from the file system at realPath into the zipfile as metadataPath.
+     * @param folder
+     * @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) {
+        this.zipFolders.push({
+            path: folder,
+            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(async (c, e) => {
+            this.yazlFile.once("error", (err) => {
+                e(this.wrapError(err, token.isCancelled));
+            });
+            const zip = this.yazlFile;
+            if (!token.isCancelled) {
+                this.zipStream = (0, fs_1.createWriteStream)(zipFile);
+                this.zipStream.once("error", (err) => {
+                    e(this.wrapError(err, token.isCancelled));
+                });
+                this.zipStream.once("close", () => {
+                    if (token.isCancelled) {
+                        e(this.canceledError());
+                    }
+                    else {
+                        c(void 0);
+                    }
+                });
+                zip.outputStream.once("error", (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();
+        });
+    }
+    /**
+     * Cancel compression.
+     * If the cancel method is called after the archive is complete, nothing will happen.
+     */
+    cancel() {
+        if (this.token) {
+            this.token.cancel();
+            this.token = null;
+        }
+        this.stopPipe(this.canceledError());
+    }
+    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 {
+            if (entry.type === "dir") {
+                zip.addEmptyDirectory(file.metadataPath, {
+                    mtime: entry.mtime,
+                    mode: entry.mode
+                });
+            }
+            else {
+                await this.addFileStream(zip, entry, file.metadataPath, token);
+            }
+        }
+    }
+    addFileStream(zip, file, metadataPath, token) {
+        return new Promise((c, e) => {
+            const fileStream = (0, 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, {
+            mtime: file.mtime,
+            mode: file.mode
+        });
+    }
+    async walkDir(folders, token) {
+        for (const folder of folders) {
+            if (token.isCancelled) {
+                return;
+            }
+            const entries = await exfs.readdirp(folder.path);
+            if (entries.length > 0) {
+                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;
+                    await this.addEntry(this.yazlFile, 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);
+                }
+            }
+        }
+    }
+    stopPipe(err) {
+        if (this.isPipe) {
+            this.yazlFile.outputStream.unpipe(this.zipStream);
+            this.zipStream.destroy(err);
+            this.isPipe = false;
+        }
+    }
+    followSymlink() {
+        let followSymlink = false;
+        if (this.options &&
+            this.options.followSymlinks === true) {
+            followSymlink = true;
+        }
+        return followSymlink;
+    }
+}
+exports.Zip = Zip;