@ffflorian/jszip-cli 3.6.4 → 3.6.5

package/dist/BuildService.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -77,23 +68,21 @@ class BuildService {
         });
         return this;
     }
-    save() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.checkOutput();
-            yield Promise.all(this.entries.map(entry => this.checkEntry(entry)));
-            const data = yield this.getBuffer();
-            if (this.outputFile) {
-                if (!this.outputFile.match(/\.\w+$/)) {
-                    this.outputFile = path_1.default.join(this.outputFile, 'data.zip');
-                }
-                this.logger.info(`Saving finished zip file to "${this.outputFile}" ...`);
-                yield this.fileService.writeFile(data, this.outputFile);
-            }
-            else {
-                process.stdout.write(data);
-            }
-            return this;
-        });
+    async save() {
+        await this.checkOutput();
+        await Promise.all(this.entries.map(entry => this.checkEntry(entry)));
+        const data = await this.getBuffer();
+        if (this.outputFile) {
+            if (!this.outputFile.match(/\.\w+$/)) {
+                this.outputFile = path_1.default.join(this.outputFile, 'data.zip');
+            }
+            this.logger.info(`Saving finished zip file to "${this.outputFile}" ...`);
+            await this.fileService.writeFile(data, this.outputFile);
+        }
+        else {
+            process.stdout.write(data);
+        }
+        return this;
     }
     /**
      * Note: glob patterns should always use / as a path separator, even on Windows systems,
@@ -103,119 +92,111 @@ class BuildService {
     normalizePaths(rawEntries) {
         return rawEntries.map(entry => entry.replace(/\\/g, '/'));
     }
-    addFile(entry_1) {
-        return __awaiter(this, arguments, void 0, function* (entry, isLink = false) {
-            const { resolvedPath, zipPath } = entry;
-            let fileStat;
-            let fileData;
+    async addFile(entry, isLink = false) {
+        const { resolvedPath, zipPath } = entry;
+        let fileStat;
+        let fileData;
+        try {
+            fileData = isLink ? await fs.readlink(resolvedPath) : await fs.readFile(resolvedPath);
+            fileStat = await fs.lstat(resolvedPath);
+        }
+        catch (error) {
+            if (!this.options.quiet) {
+                this.logger.info(`Can't read file "${entry.resolvedPath}". Ignoring.`);
+            }
+            this.logger.info(error);
+            return;
+        }
+        this.logger.info(`Adding file "${resolvedPath}" to ZIP file ...`);
+        this.jszip.file(zipPath, fileData, {
+            createFolders: true,
+            date: fileStat.mtime,
+            // See https://github.com/Stuk/jszip/issues/550
+            // dosPermissions: fileStat.mode,
+            unixPermissions: fileStat.mode,
+        });
+        this.compressedFilesCount++;
+    }
+    async addLink(entry) {
+        const { resolvedPath, zipPath } = entry;
+        if (this.options.dereferenceLinks) {
+            let realPath;
             try {
-                fileData = isLink ? yield fs.readlink(resolvedPath) : yield fs.readFile(resolvedPath);
-                fileStat = yield fs.lstat(resolvedPath);
+                realPath = await fs.realpath(resolvedPath);
             }
             catch (error) {
                 if (!this.options.quiet) {
-                    this.logger.info(`Can't read file "${entry.resolvedPath}". Ignoring.`);
+                    this.logger.info(`Can't read link "${entry.resolvedPath}". Ignoring.`);
                 }
                 this.logger.info(error);
                 return;
             }
-            this.logger.info(`Adding file "${resolvedPath}" to ZIP file ...`);
-            this.jszip.file(zipPath, fileData, {
-                createFolders: true,
-                date: fileStat.mtime,
-                // See https://github.com/Stuk/jszip/issues/550
-                // dosPermissions: fileStat.mode,
-                unixPermissions: fileStat.mode,
+            this.logger.info(`Found real path "${realPath} for symbolic link".`);
+            await this.checkEntry({
+                resolvedPath: realPath,
+                zipPath,
             });
-            this.compressedFilesCount++;
-        });
+        }
+        else {
+            await this.addFile(entry, true);
+        }
     }
-    addLink(entry) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { resolvedPath, zipPath } = entry;
-            if (this.options.dereferenceLinks) {
-                let realPath;
-                try {
-                    realPath = yield fs.realpath(resolvedPath);
-                }
-                catch (error) {
-                    if (!this.options.quiet) {
-                        this.logger.info(`Can't read link "${entry.resolvedPath}". Ignoring.`);
-                    }
-                    this.logger.info(error);
-                    return;
-                }
-                this.logger.info(`Found real path "${realPath} for symbolic link".`);
-                yield this.checkEntry({
-                    resolvedPath: realPath,
-                    zipPath,
-                });
-            }
-            else {
-                yield this.addFile(entry, true);
-            }
-        });
+    async checkEntry(entry) {
+        let fileStat;
+        try {
+            fileStat = await fs.lstat(entry.resolvedPath);
+        }
+        catch (error) {
+            if (!this.options.quiet) {
+                this.logger.info(`Can't read file "${entry.resolvedPath}". Ignoring.`);
+            }
+            this.logger.info(error);
+            return;
+        }
+        const ignoreEntries = this.ignoreEntries.filter(ignoreEntry => Boolean(entry.resolvedPath.match(ignoreEntry)));
+        if (ignoreEntries.length) {
+            this.logger.info(`Found ${entry.resolvedPath}. Not adding since it's on the ignore list:`, ignoreEntries.map(entry => String(entry)));
+            return;
+        }
+        if (fileStat.isDirectory()) {
+            this.logger.info(`Found directory "${entry.resolvedPath}".`);
+            await this.walkDir(entry);
+        }
+        else if (fileStat.isFile()) {
+            this.logger.info(`Found file "${entry.resolvedPath}".`);
+            this.logger.info(`Found file "${entry.resolvedPath}".`);
+            await this.addFile(entry);
+        }
+        else if (fileStat.isSymbolicLink()) {
+            this.logger.info(`Found symbolic link "${entry.resolvedPath}".`);
+            await this.addLink(entry);
+        }
+        else {
+            this.logger.info('Unknown file type.', { fileStat });
+            if (!this.options.quiet) {
+                this.logger.info(`Can't read file "${entry.resolvedPath}". Ignoring.`);
+            }
+        }
     }
-    checkEntry(entry) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let fileStat;
-            try {
-                fileStat = yield fs.lstat(entry.resolvedPath);
-            }
-            catch (error) {
-                if (!this.options.quiet) {
-                    this.logger.info(`Can't read file "${entry.resolvedPath}". Ignoring.`);
+    async checkOutput() {
+        if (this.outputFile) {
+            if (this.outputFile.match(/\.\w+$/)) {
+                const dirExists = await this.fileService.dirExists(path_1.default.dirname(this.outputFile));
+                if (!dirExists) {
+                    throw new Error(`Directory "${path_1.default.dirname(this.outputFile)}" doesn't exist or is not writable.`);
                 }
-                this.logger.info(error);
-                return;
-            }
-            const ignoreEntries = this.ignoreEntries.filter(ignoreEntry => Boolean(entry.resolvedPath.match(ignoreEntry)));
-            if (ignoreEntries.length) {
-                this.logger.info(`Found ${entry.resolvedPath}. Not adding since it's on the ignore list:`, ignoreEntries.map(entry => String(entry)));
-                return;
-            }
-            if (fileStat.isDirectory()) {
-                this.logger.info(`Found directory "${entry.resolvedPath}".`);
-                yield this.walkDir(entry);
-            }
-            else if (fileStat.isFile()) {
-                this.logger.info(`Found file "${entry.resolvedPath}".`);
-                this.logger.info(`Found file "${entry.resolvedPath}".`);
-                yield this.addFile(entry);
-            }
-            else if (fileStat.isSymbolicLink()) {
-                this.logger.info(`Found symbolic link "${entry.resolvedPath}".`);
-                yield this.addLink(entry);
-            }
-            else {
-                this.logger.info('Unknown file type.', { fileStat });
-                if (!this.options.quiet) {
-                    this.logger.info(`Can't read file "${entry.resolvedPath}". Ignoring.`);
+                const fileIsWritable = await this.fileService.fileIsWritable(this.outputFile);
+                if (!fileIsWritable) {
+                    throw new Error(`File "${this.outputFile}" already exists.`);
                 }
             }
-        });
-    }
-    checkOutput() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.outputFile) {
-                if (this.outputFile.match(/\.\w+$/)) {
-                    const dirExists = yield this.fileService.dirExists(path_1.default.dirname(this.outputFile));
-                    if (!dirExists) {
-                        throw new Error(`Directory "${path_1.default.dirname(this.outputFile)}" doesn't exist or is not writable.`);
-                    }
-                    const fileIsWritable = yield this.fileService.fileIsWritable(this.outputFile);
-                    if (!fileIsWritable) {
-                        throw new Error(`File "${this.outputFile}" already exists.`);
-                    }
-                }
-                else {
-                    const dirExists = yield this.fileService.dirExists(this.outputFile);
-                    if (!dirExists) {
-                        throw new Error(`Directory "${this.outputFile}" doesn't exist or is not writable.`);
-                    }
+            else {
+                const dirExists = await this.fileService.dirExists(this.outputFile);
+                if (!dirExists) {
+                    throw new Error(`Directory "${this.outputFile}" doesn't exist or is not writable.`);
                 }
             }
-        });
+        }
     }
     getBuffer() {
         const compressionType = this.options.compressionLevel === 0 ? 'STORE' : 'DEFLATE';
@@ -234,19 +215,17 @@ class BuildService {
             }
         });
     }
-    walkDir(entry) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.info(`Walking directory ${entry.resolvedPath} ...`);
-            const dirEntries = yield fs.readdir(entry.resolvedPath);
-            for (const dirEntry of dirEntries) {
-                const newZipPath = entry.zipPath === '.' ? dirEntry : `${entry.zipPath}/${dirEntry}`;
-                const newResolvedPath = path_1.default.join(entry.resolvedPath, dirEntry);
-                yield this.checkEntry({
-                    resolvedPath: newResolvedPath,
-                    zipPath: newZipPath,
-                });
-            }
-        });
+    async walkDir(entry) {
+        this.logger.info(`Walking directory ${entry.resolvedPath} ...`);
+        const dirEntries = await fs.readdir(entry.resolvedPath);
+        for (const dirEntry of dirEntries) {
+            const newZipPath = entry.zipPath === '.' ? dirEntry : `${entry.zipPath}/${dirEntry}`;
+            const newResolvedPath = path_1.default.join(entry.resolvedPath, dirEntry);
+            await this.checkEntry({
+                resolvedPath: newResolvedPath,
+                zipPath: newZipPath,
+            });
+        }
     }
 }
 exports.BuildService = BuildService;

package/dist/ExtractService.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -36,60 +27,58 @@ class ExtractService {
         });
         this.extractedFilesCount = 0;
     }
-    extract(rawEntries) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isWin32 = os_1.default.platform() === 'win32';
-            for (const entry of rawEntries) {
-                const jszip = new jszip_1.default();
-                if (this.outputDir) {
-                    yield fs_extra_1.default.ensureDir(this.outputDir);
+    async extract(rawEntries) {
+        const isWin32 = os_1.default.platform() === 'win32';
+        for (const entry of rawEntries) {
+            const jszip = new jszip_1.default();
+            if (this.outputDir) {
+                await fs_extra_1.default.ensureDir(this.outputDir);
+            }
+            const resolvedPath = path_1.default.resolve(entry);
+            const data = await fs_extra_1.default.readFile(resolvedPath);
+            const entries = [];
+            await jszip.loadAsync(data, { createFolders: true });
+            if (!this.outputDir) {
+                await this.printStream(jszip.generateNodeStream());
+                return this;
+            }
+            jszip.forEach((filePath, entry) => {
+                if (filePath.includes('..')) {
+                    this.logger.info(`Skipping bad path "${filePath}"`);
                 }
-                const resolvedPath = path_1.default.resolve(entry);
-                const data = yield fs_extra_1.default.readFile(resolvedPath);
-                const entries = [];
-                yield jszip.loadAsync(data, { createFolders: true });
-                if (!this.outputDir) {
-                    yield this.printStream(jszip.generateNodeStream());
-                    return this;
+                else {
+                    entries.push([filePath, entry]);
                 }
-                jszip.forEach((filePath, entry) => {
-                    if (filePath.includes('..')) {
-                        this.logger.info(`Skipping bad path "${filePath}"`);
-                    }
-                    else {
-                        entries.push([filePath, entry]);
-                    }
-                });
-                let lastPercent = 0;
-                yield Promise.all(entries.map((_a, index_1) => __awaiter(this, [_a, index_1], void 0, function* ([filePath, entry], index) {
-                    const resolvedFilePath = path_1.default.join(this.outputDir, filePath);
-                    if (entry.dir) {
-                        yield fs_extra_1.default.ensureDir(resolvedFilePath);
-                    }
-                    else {
-                        const data = yield entry.async('nodebuffer');
-                        yield fs_extra_1.default.writeFile(resolvedFilePath, data, {
-                            encoding: 'utf-8',
-                        });
-                        this.extractedFilesCount++;
-                        const diff = Math.floor(index / entries.length) - Math.floor(lastPercent);
-                        if (diff && !this.options.quiet) {
-                            this.progressBar.tick(diff);
-                            lastPercent = Math.floor(index / entries.length);
-                        }
-                    }
-                    if (isWin32) {
-                        if (entry.dosPermissions) {
-                            yield fs_extra_1.default.chmod(resolvedFilePath, entry.dosPermissions);
-                        }
+            });
+            let lastPercent = 0;
+            await Promise.all(entries.map(async ([filePath, entry], index) => {
+                const resolvedFilePath = path_1.default.join(this.outputDir, filePath);
+                if (entry.dir) {
+                    await fs_extra_1.default.ensureDir(resolvedFilePath);
+                }
+                else {
+                    const data = await entry.async('nodebuffer');
+                    await fs_extra_1.default.writeFile(resolvedFilePath, data, {
+                        encoding: 'utf-8',
+                    });
+                    this.extractedFilesCount++;
+                    const diff = Math.floor(index / entries.length) - Math.floor(lastPercent);
+                    if (diff && !this.options.quiet) {
+                        this.progressBar.tick(diff);
+                        lastPercent = Math.floor(index / entries.length);
                     }
-                    else if (entry.unixPermissions) {
-                        yield fs_extra_1.default.chmod(resolvedFilePath, entry.unixPermissions);
+                }
+                if (isWin32) {
+                    if (entry.dosPermissions) {
+                        await fs_extra_1.default.chmod(resolvedFilePath, entry.dosPermissions);
                     }
-                })));
-            }
-            return this;
-        });
+                }
+                else if (entry.unixPermissions) {
+                    await fs_extra_1.default.chmod(resolvedFilePath, entry.unixPermissions);
+                }
+            }));
+        }
+        return this;
     }
     printStream(fileStream) {
         return new Promise((resolve, reject) => {

package/dist/FileService.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { TerminalOptions } from './interfaces';
 export declare class FileService {
     private readonly logger;

package/dist/FileService.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -25,70 +16,62 @@ class FileService {
         });
         this.logger.state.isEnabled = this.options.verbose;
     }
-    dirExists(dirPath) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async dirExists(dirPath) {
+        try {
+            await fs_extra_1.default.access(dirPath, fs_extra_1.default.constants.F_OK);
             try {
-                yield fs_extra_1.default.access(dirPath, fs_extra_1.default.constants.F_OK);
-                try {
-                    yield fs_extra_1.default.access(dirPath, fs_extra_1.default.constants.W_OK);
-                    return true;
-                }
-                catch (error) {
-                    this.logger.info(`Directory "${dirPath}" exists but is not writable.`);
-                    return false;
-                }
+                await fs_extra_1.default.access(dirPath, fs_extra_1.default.constants.W_OK);
+                return true;
             }
             catch (error) {
-                this.logger.info(`Directory "${dirPath}" doesn't exist.`, this.options.force ? 'Creating.' : 'Not creating.');
-                if (this.options.force) {
-                    yield fs_extra_1.default.ensureDir(dirPath);
-                    return true;
-                }
+                this.logger.info(`Directory "${dirPath}" exists but is not writable.`);
                 return false;
             }
-        });
-    }
-    fileIsReadable(filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dirExists = yield this.dirExists(path_1.default.dirname(filePath));
-            if (dirExists) {
-                try {
-                    yield fs_extra_1.default.access(filePath, fs_extra_1.default.constants.F_OK | fs_extra_1.default.constants.R_OK);
-                    return true;
-                }
-                catch (error) {
-                    return false;
-                }
+        }
+        catch (error) {
+            this.logger.info(`Directory "${dirPath}" doesn't exist.`, this.options.force ? 'Creating.' : 'Not creating.');
+            if (this.options.force) {
+                await fs_extra_1.default.ensureDir(dirPath);
+                return true;
             }
             return false;
-        });
+        }
     }
-    fileIsWritable(filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dirName = path_1.default.dirname(filePath);
-            const dirExists = yield this.dirExists(dirName);
-            if (dirExists) {
-                try {
-                    yield fs_extra_1.default.access(filePath, fs_extra_1.default.constants.F_OK | fs_extra_1.default.constants.R_OK);
-                    this.logger.info(`File "${filePath}" already exists.`, this.options.force ? 'Forcing overwrite.' : 'Not overwriting.');
-                    return this.options.force;
-                }
-                catch (error) {
-                    return true;
-                }
+    async fileIsReadable(filePath) {
+        const dirExists = await this.dirExists(path_1.default.dirname(filePath));
+        if (dirExists) {
+            try {
+                await fs_extra_1.default.access(filePath, fs_extra_1.default.constants.F_OK | fs_extra_1.default.constants.R_OK);
+                return true;
             }
-            return false;
-        });
+            catch (error) {
+                return false;
+            }
+        }
+        return false;
     }
-    writeFile(data, filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fileIsWritable = yield this.fileIsWritable(filePath);
-            if (fileIsWritable) {
-                yield fs_extra_1.default.writeFile(filePath, data);
-                return this;
+    async fileIsWritable(filePath) {
+        const dirName = path_1.default.dirname(filePath);
+        const dirExists = await this.dirExists(dirName);
+        if (dirExists) {
+            try {
+                await fs_extra_1.default.access(filePath, fs_extra_1.default.constants.F_OK | fs_extra_1.default.constants.R_OK);
+                this.logger.info(`File "${filePath}" already exists.`, this.options.force ? 'Forcing overwrite.' : 'Not overwriting.');
+                return this.options.force;
             }
-            throw new Error(`File "${this.options.outputEntry}" already exists.`);
-        });
+            catch (error) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async writeFile(data, filePath) {
+        const fileIsWritable = await this.fileIsWritable(filePath);
+        if (fileIsWritable) {
+            await fs_extra_1.default.writeFile(filePath, data);
+            return this;
+        }
+        throw new Error(`File "${this.options.outputEntry}" already exists.`);
     }
 }
 exports.FileService = FileService;

package/dist/JSZipCLI.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -35,7 +26,7 @@ class JSZipCLI {
             markdown: false,
         });
         this.configExplorer = (0, cosmiconfig_1.cosmiconfigSync)('jszip');
-        this.options = Object.assign(Object.assign({}, defaultOptions), this.terminalOptions);
+        this.options = { ...defaultOptions, ...this.terminalOptions };
         this.logger.state.isEnabled = this.options.verbose;
         this.logger.info('Merged options', this.options);
         this.checkConfigFile();
@@ -79,27 +70,25 @@ class JSZipCLI {
      * Run in file mode - reads entries and settings from configuration file.
      * Options from the constructor still take precedence.
      */
-    fileMode() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.options.mode && !this.configFile) {
-                throw new Error('No configuration file and no mode specified.');
-            }
-            if (this.options.mode === 'add') {
-                const { outputFile, compressedFilesCount } = yield this.add().save();
-                if (this.options.outputEntry && !this.options.quiet) {
-                    console.info(`Done compressing ${compressedFilesCount} files to "${outputFile}".`);
-                }
-                return this;
+    async fileMode() {
+        if (!this.options.mode && !this.configFile) {
+            throw new Error('No configuration file and no mode specified.');
+        }
+        if (this.options.mode === 'add') {
+            const { outputFile, compressedFilesCount } = await this.add().save();
+            if (this.options.outputEntry && !this.options.quiet) {
+                console.info(`Done compressing ${compressedFilesCount} files to "${outputFile}".`);
             }
-            else if (this.options.mode === 'extract') {
-                const { outputDir, extractedFilesCount } = yield this.extract();
-                if (this.options.outputEntry && !this.options.quiet) {
-                    console.info(`Done extracting ${extractedFilesCount} files to "${outputDir}".`);
-                }
-                return this;
+            return this;
+        }
+        else if (this.options.mode === 'extract') {
+            const { outputDir, extractedFilesCount } = await this.extract();
+            if (this.options.outputEntry && !this.options.quiet) {
+                console.info(`Done extracting ${extractedFilesCount} files to "${outputDir}".`);
             }
-            throw new Error('No or invalid mode in configuration file defined.');
-        });
+            return this;
+        }
+        throw new Error('No or invalid mode in configuration file defined.');
     }
     save() {
         return this.buildService.save();
@@ -132,7 +121,7 @@ class JSZipCLI {
         }
         const configFileData = configResult.config;
         this.logger.info(`Using configuration file ${configResult.filepath}`);
-        this.options = Object.assign(Object.assign(Object.assign({}, defaultOptions), configFileData), this.terminalOptions);
+        this.options = { ...defaultOptions, ...configFileData, ...this.terminalOptions };
         this.logger.state.isEnabled = this.options.verbose;
     }
 }

package/dist/cli.js

@@ -1,14 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -53,12 +44,21 @@ commander_1.program
     .option('-q, --quiet', "don't log anything excluding errors", false)
     .option('-V, --verbose', 'enable verbose logging', false)
     .arguments('[entries...]')
-    .action((entries) => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async (entries) => {
     const options = commander_1.program.opts();
     try {
-        const jszip = new JSZipCLI_1.JSZipCLI(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (options.level && { compressionLevel: Number(options.level) })), ((options.config && { configFile: options.config }) || (options.noconfig && { configFile: false }))), (options.dereference && { dereferenceLinks: options.dereference })), (options.force && { force: options.force })), (options.ignore && { ignoreEntries: [options.ignore] })), (options.output && { outputEntry: options.output })), (options.quiet && { quiet: options.quiet })), (options.verbose && { verbose: options.verbose })));
+        const jszip = new JSZipCLI_1.JSZipCLI({
+            ...(options.level && { compressionLevel: Number(options.level) }),
+            ...((options.config && { configFile: options.config }) || (options.noconfig && { configFile: false })),
+            ...(options.dereference && { dereferenceLinks: options.dereference }),
+            ...(options.force && { force: options.force }),
+            ...(options.ignore && { ignoreEntries: [options.ignore] }),
+            ...(options.output && { outputEntry: options.output }),
+            ...(options.quiet && { quiet: options.quiet }),
+            ...(options.verbose && { verbose: options.verbose }),
+        });
         jszip.add(entries);
-        const { outputFile, compressedFilesCount } = yield jszip.save();
+        const { outputFile, compressedFilesCount } = await jszip.save();
         if (options.output && !options.quiet) {
             console.info(`Done compressing ${compressedFilesCount} files to "${outputFile}".`);
         }
@@ -67,7 +67,7 @@ commander_1.program
         console.error('Error:', error.message);
         process.exit(1);
     }
-}));
+});
 commander_1.program
     .command('extract')
     .alias('e')
@@ -80,10 +80,17 @@ commander_1.program
     .option('-V, --verbose', 'enable verbose logging', false)
     .option('-q, --quiet', "don't log anything excluding errors", false)
     .arguments('<archives...>')
-    .action((archives) => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async (archives) => {
     const options = commander_1.program.opts();
     try {
-        const { outputDir, extractedFilesCount } = yield new JSZipCLI_1.JSZipCLI(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, ((options.config && { configFile: options.config }) || (options.noconfig && { configFile: false }))), (options.force && { force: options.force })), (options.ignore && { ignoreEntries: [options.ignore] })), (options.output && { outputEntry: options.output })), (options.quiet && { quiet: options.quiet })), (options.verbose && { verbose: options.verbose }))).extract(archives);
+        const { outputDir, extractedFilesCount } = await new JSZipCLI_1.JSZipCLI({
+            ...((options.config && { configFile: options.config }) || (options.noconfig && { configFile: false })),
+            ...(options.force && { force: options.force }),
+            ...(options.ignore && { ignoreEntries: [options.ignore] }),
+            ...(options.output && { outputEntry: options.output }),
+            ...(options.quiet && { quiet: options.quiet }),
+            ...(options.verbose && { verbose: options.verbose }),
+        }).extract(archives);
         if (options.output && !options.quiet) {
             console.info(`Done extracting ${extractedFilesCount} files to "${outputDir}".`);
         }
@@ -92,7 +99,7 @@ commander_1.program
         console.error('Error:', error.message);
         process.exit(1);
     }
-}));
+});
 commander_1.program
     .command('fileMode', { hidden: true, isDefault: true })
     .option('--noconfig', "don't look for a configuration file", false)
@@ -102,13 +109,20 @@ commander_1.program
     .option('-f, --force', 'force overwriting files and directories', false)
     .option('-V, --verbose', 'enable verbose logging', false)
     .option('-q, --quiet', "don't log anything excluding errors", false)
-    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async () => {
     const options = commander_1.program.opts();
     try {
         if (options.noconfig) {
             commander_1.program.outputHelp();
         }
-        yield new JSZipCLI_1.JSZipCLI(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (options.config && { configFile: options.config })), (options.force && { force: options.force })), (options.ignore && { ignoreEntries: [options.ignore] })), (options.output && { outputEntry: options.output })), (options.quiet && { quiet: options.quiet })), (options.verbose && { verbose: options.verbose }))).fileMode();
+        await new JSZipCLI_1.JSZipCLI({
+            ...(options.config && { configFile: options.config }),
+            ...(options.force && { force: options.force }),
+            ...(options.ignore && { ignoreEntries: [options.ignore] }),
+            ...(options.output && { outputEntry: options.output }),
+            ...(options.quiet && { quiet: options.quiet }),
+            ...(options.verbose && { verbose: options.verbose }),
+        }).fileMode();
     }
     catch (error) {
         if (error.message.includes('ENOENT')) {
@@ -119,5 +133,5 @@ commander_1.program
         }
         process.exit(1);
     }
-}));
+});
 commander_1.program.parse(process.argv);

package/package.json

@@ -17,7 +17,7 @@
     "cross-env": "7.0.3",
     "rimraf": "5.0.7",
     "ts-node": "10.9.2",
-    "typescript": "5.4.5",
+    "typescript": "5.5.2",
     "vitest": "1.6.0"
   },
   "engines": {
@@ -43,6 +43,6 @@
     "start": "cross-env NODE_DEBUG=\"jszip-cli/*\" node --loader ts-node/esm src/cli.ts",
     "test": "vitest run"
   },
-  "version": "3.6.4",
-  "gitHead": "28c184f53a87d8eb082cc27c923ef7b352bbe875"
+  "version": "3.6.5",
+  "gitHead": "f7a6a79286e4eb85392b5f2d33942ab166142109"
 }