@akylas/nativescript-cli 8.8.2 → 8.8.3

package/lib/common/errors.js

@@ -5,17 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Errors = exports.installUncaughtExceptionListener = void 0;
+exports.Errors = void 0;
+exports.installUncaughtExceptionListener = installUncaughtExceptionListener;
 const util = require("util");
 const path = require("path");
 const _ = require("lodash");
@@ -26,68 +18,66 @@ const yok_1 = require("./yok");
 function Exception() {
 }
 Exception.prototype = new Error();
-function resolveCallStack(error) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const stackLines = error.stack.split("\n");
-        const parsed = _.map(stackLines, (line) => {
-            let match = line.match(/^\s*at ([^(]*) \((.*?):([0-9]+):([0-9]+)\)$/);
-            if (match) {
-                return match;
-            }
-            match = line.match(/^\s*at (.*?):([0-9]+):([0-9]+)$/);
-            if (match) {
-                match.splice(1, 0, "<anonymous>");
-                return match;
-            }
-            return line;
-        });
-        const fs = require("fs");
-        const remapped = yield Promise.all(_.map(parsed, (parsedLine) => __awaiter(this, void 0, void 0, function* () {
-            if (_.isString(parsedLine)) {
-                return parsedLine;
-            }
-            const functionName = parsedLine[1];
-            const fileName = parsedLine[2];
-            const line = +parsedLine[3];
-            const column = +parsedLine[4];
-            const mapFileName = fileName + ".map";
-            if (!fs.existsSync(mapFileName)) {
-                return parsedLine.input;
-            }
-            const mapData = JSON.parse(fs.readFileSync(mapFileName).toString());
-            return yield source_map_1.SourceMapConsumer.with(mapData, null, (consumer) => {
-                const sourcePos = consumer.originalPositionFor({
-                    line: line,
-                    column: column,
-                });
-                if (sourcePos && sourcePos.source) {
-                    const source = path.join(path.dirname(fileName), sourcePos.source);
-                    return util.format("    at %s (%s:%s:%s)", functionName, source, sourcePos.line, sourcePos.column);
-                }
-                return util.format("    at %s (%s:%s:%s)", functionName, fileName, line, column);
-            });
-        })));
-        let outputMessage = remapped.join("\n");
-        if (outputMessage.indexOf(error.message) === -1) {
-            outputMessage = outputMessage.replace(/Error/, "Error: " + error.message);
+async function resolveCallStack(error) {
+    const stackLines = error.stack.split("\n");
+    const parsed = _.map(stackLines, (line) => {
+        let match = line.match(/^\s*at ([^(]*) \((.*?):([0-9]+):([0-9]+)\)$/);
+        if (match) {
+            return match;
         }
-        return outputMessage;
+        match = line.match(/^\s*at (.*?):([0-9]+):([0-9]+)$/);
+        if (match) {
+            match.splice(1, 0, "<anonymous>");
+            return match;
+        }
+        return line;
     });
+    const fs = require("fs");
+    const remapped = await Promise.all(_.map(parsed, async (parsedLine) => {
+        if (_.isString(parsedLine)) {
+            return parsedLine;
+        }
+        const functionName = parsedLine[1];
+        const fileName = parsedLine[2];
+        const line = +parsedLine[3];
+        const column = +parsedLine[4];
+        const mapFileName = fileName + ".map";
+        if (!fs.existsSync(mapFileName)) {
+            return parsedLine.input;
+        }
+        const mapData = JSON.parse(fs.readFileSync(mapFileName).toString());
+        return await source_map_1.SourceMapConsumer.with(mapData, null, (consumer) => {
+            const sourcePos = consumer.originalPositionFor({
+                line: line,
+                column: column,
+            });
+            if (sourcePos && sourcePos.source) {
+                const source = path.join(path.dirname(fileName), sourcePos.source);
+                return util.format("    at %s (%s:%s:%s)", functionName, source, sourcePos.line, sourcePos.column);
+            }
+            return util.format("    at %s (%s:%s:%s)", functionName, fileName, line, column);
+        });
+    }));
+    let outputMessage = remapped.join("\n");
+    if (outputMessage.indexOf(error.message) === -1) {
+        outputMessage = outputMessage.replace(/Error/, "Error: " + error.message);
+    }
+    return outputMessage;
 }
 function installUncaughtExceptionListener(actionOnException) {
-    const handler = (err) => __awaiter(this, void 0, void 0, function* () {
+    const handler = async (err) => {
         try {
             let callstack = err.stack;
             if (callstack) {
                 try {
-                    callstack = yield resolveCallStack(err);
+                    callstack = await resolveCallStack(err);
                 }
                 catch (err) {
                     console.error("Error while resolving callStack:", err);
                 }
             }
             console.error(callstack || err.toString());
-            yield tryTrackException(err, yok_1.injector);
+            await tryTrackException(err, yok_1.injector);
             if (actionOnException) {
                 actionOnException();
             }
@@ -95,30 +85,27 @@ function installUncaughtExceptionListener(actionOnException) {
         catch (err) {
             process.exit(131);
         }
-    });
+    };
     process.on("uncaughtException", handler);
     process.on("unhandledRejection", handler);
 }
-exports.installUncaughtExceptionListener = installUncaughtExceptionListener;
-function tryTrackException(error, localInjector) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let disableAnalytics;
+async function tryTrackException(error, localInjector) {
+    let disableAnalytics;
+    try {
+        disableAnalytics = localInjector.resolve("staticConfig").disableAnalytics;
+    }
+    catch (err) {
+        disableAnalytics = true;
+    }
+    if (!disableAnalytics) {
         try {
-            disableAnalytics = localInjector.resolve("staticConfig").disableAnalytics;
+            const analyticsService = localInjector.resolve("analyticsService");
+            await analyticsService.trackException(error, error.message);
         }
-        catch (err) {
-            disableAnalytics = true;
+        catch (e) {
+            console.error("Error while reporting exception: " + e);
         }
-        if (!disableAnalytics) {
-            try {
-                const analyticsService = localInjector.resolve("analyticsService");
-                yield analyticsService.trackException(error, error.message);
-            }
-            catch (e) {
-                console.error("Error while reporting exception: " + e);
-            }
-        }
-    });
+    }
 }
 class Errors {
     constructor($injector) {
@@ -162,35 +149,33 @@ class Errors {
         this.$injector.resolve("logger").trace(opts.formatStr);
         throw exception;
     }
-    beginCommand(action, printCommandHelpSuggestion) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield action();
+    async beginCommand(action, printCommandHelpSuggestion) {
+        try {
+            return await action();
+        }
+        catch (ex) {
+            const logger = this.$injector.resolve("logger");
+            const loggerLevel = logger.getLevel().toUpperCase();
+            const printCallStack = this.printCallStack ||
+                loggerLevel === "TRACE" ||
+                loggerLevel === "DEBUG";
+            const message = printCallStack
+                ? await resolveCallStack(ex)
+                : (0, helpers_1.isInteractive)()
+                    ? `\x1B[31;1m${ex.message}\x1B[0m`
+                    : ex.message;
+            if (ex.printOnStdout) {
+                logger.info(message);
             }
-            catch (ex) {
-                const logger = this.$injector.resolve("logger");
-                const loggerLevel = logger.getLevel().toUpperCase();
-                const printCallStack = this.printCallStack ||
-                    loggerLevel === "TRACE" ||
-                    loggerLevel === "DEBUG";
-                const message = printCallStack
-                    ? yield resolveCallStack(ex)
-                    : (0, helpers_1.isInteractive)()
-                        ? `\x1B[31;1m${ex.message}\x1B[0m`
-                        : ex.message;
-                if (ex.printOnStdout) {
-                    logger.info(message);
-                }
-                else {
-                    logger.error(message);
-                }
-                if (ex.suggestCommandHelp) {
-                    yield printCommandHelpSuggestion();
-                }
-                yield tryTrackException(ex, this.$injector);
-                process.exit(_.isNumber(ex.errorCode) ? ex.errorCode : 127);
+            else {
+                logger.error(message);
             }
-        });
+            if (ex.suggestCommandHelp) {
+                await printCommandHelpSuggestion();
+            }
+            await tryTrackException(ex, this.$injector);
+            process.exit(_.isNumber(ex.errorCode) ? ex.errorCode : 127);
+        }
     }
     verifyHeap(message) {
         if (global.gc) {
@@ -199,8 +184,8 @@ class Errors {
         }
     }
 }
+exports.Errors = Errors;
 __decorate([
     (0, decorators_1.deprecated)("Use `fail` instead.")
 ], Errors.prototype, "failWithoutHelp", null);
-exports.Errors = Errors;
 yok_1.injector.register("errors", Errors);

package/lib/common/file-system.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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 FileSystem_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSystem = void 0;
@@ -27,76 +18,72 @@ const shelljs = require("shelljs");
 const helpers_1 = require("./helpers");
 const constants_1 = require("../constants");
 const os_1 = require("os");
-const detectNewline = require("detect-newline");
 const archiver_1 = require("archiver");
 const stringifyPackage = require("stringify-package");
 const mkdirp = require("mkdirp");
+const detectNewline = require("detect-newline");
 let FileSystem = FileSystem_1 = class FileSystem {
     constructor($injector) {
         this.$injector = $injector;
     }
-    zipFiles(zipFile, files, zipPathCallback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const $logger = this.$injector.resolve("logger");
-            const zip = (0, archiver_1.create)("zip", {
-                zlib: {
-                    level: 9,
-                },
-            });
-            const outFile = fs.createWriteStream(zipFile);
-            zip.pipe(outFile);
-            return new Promise((resolve, reject) => {
-                outFile.on("error", (err) => reject(err));
-                outFile.on("close", () => {
-                    $logger.trace("zip: %d bytes written", zip.pointer());
-                    resolve();
-                });
-                for (const file of files) {
-                    let relativePath = zipPathCallback(file);
-                    relativePath = relativePath.replace(/\\/g, "/");
-                    $logger.trace("zipping as '%s' file '%s'", relativePath, file);
-                    zip.append(fs.createReadStream(file), { name: relativePath });
-                }
-                zip.finalize();
+    async zipFiles(zipFile, files, zipPathCallback) {
+        const $logger = this.$injector.resolve("logger");
+        const zip = (0, archiver_1.create)("zip", {
+            zlib: {
+                level: 9,
+            },
+        });
+        const outFile = fs.createWriteStream(zipFile);
+        zip.pipe(outFile);
+        return new Promise((resolve, reject) => {
+            outFile.on("error", (err) => reject(err));
+            outFile.on("close", () => {
+                $logger.trace("zip: %d bytes written", zip.pointer());
+                resolve();
             });
+            for (const file of files) {
+                let relativePath = zipPathCallback(file);
+                relativePath = relativePath.replace(/\\/g, "/");
+                $logger.trace("zipping as '%s' file '%s'", relativePath, file);
+                zip.append(fs.createReadStream(file), { name: relativePath });
+            }
+            zip.finalize();
         });
     }
     utimes(path, atime, mtime) {
         return fs.utimesSync(path, atime, mtime);
     }
-    unzip(zipFile, destinationDir, options, fileFilters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const shouldOverwriteFiles = !(options && options.overwriteExisitingFiles === false);
-            const isCaseSensitive = !(options && options.caseSensitive === false);
-            const $hostInfo = this.$injector.resolve("$hostInfo");
-            this.createDirectory(destinationDir);
-            let proc;
-            if ($hostInfo.isWindows) {
-                proc = (0, path_1.join)(__dirname, "resources/platform-tools/unzip/win32/unzip");
-            }
-            else if ($hostInfo.isDarwin) {
-                proc = "unzip";
-            }
-            else if ($hostInfo.isLinux) {
-                proc = "unzip";
-            }
-            if (!isCaseSensitive) {
-                zipFile = this.findFileCaseInsensitive(zipFile);
-            }
-            const args = _.flatten([
-                "-b",
-                shouldOverwriteFiles ? "-o" : "-n",
-                isCaseSensitive ? [] : "-C",
-                zipFile,
-                fileFilters || [],
-                "-d",
-                destinationDir,
-            ]);
-            const $childProcess = this.$injector.resolve("childProcess");
-            yield $childProcess.spawnFromEvent(proc, args, "close", {
-                stdio: "ignore",
-                detached: true,
-            });
+    async unzip(zipFile, destinationDir, options, fileFilters) {
+        const shouldOverwriteFiles = !(options && options.overwriteExisitingFiles === false);
+        const isCaseSensitive = !(options && options.caseSensitive === false);
+        const $hostInfo = this.$injector.resolve("$hostInfo");
+        this.createDirectory(destinationDir);
+        let proc;
+        if ($hostInfo.isWindows) {
+            proc = (0, path_1.join)(__dirname, "resources/platform-tools/unzip/win32/unzip");
+        }
+        else if ($hostInfo.isDarwin) {
+            proc = "unzip";
+        }
+        else if ($hostInfo.isLinux) {
+            proc = "unzip";
+        }
+        if (!isCaseSensitive) {
+            zipFile = this.findFileCaseInsensitive(zipFile);
+        }
+        const args = _.flatten([
+            "-b",
+            shouldOverwriteFiles ? "-o" : "-n",
+            isCaseSensitive ? [] : "-C",
+            zipFile,
+            fileFilters || [],
+            "-d",
+            destinationDir,
+        ]);
+        const $childProcess = this.$injector.resolve("childProcess");
+        await $childProcess.spawnFromEvent(proc, args, "close", {
+            stdio: "ignore",
+            detached: true,
         });
     }
     findFileCaseInsensitive(file) {
@@ -168,28 +155,26 @@ let FileSystem = FileSystem_1 = class FileSystem {
             return 0;
         }
     }
-    futureFromEvent(eventEmitter, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                eventEmitter.once(event, function () {
-                    const args = _.toArray(arguments);
-                    if (event === "error") {
-                        const err = args[0];
-                        reject(err);
-                        return;
-                    }
-                    switch (args.length) {
-                        case 0:
-                            resolve(undefined);
-                            break;
-                        case 1:
-                            resolve(args[0]);
-                            break;
-                        default:
-                            resolve(args);
-                            break;
-                    }
-                });
+    async futureFromEvent(eventEmitter, event) {
+        return new Promise((resolve, reject) => {
+            eventEmitter.once(event, function () {
+                const args = _.toArray(arguments);
+                if (event === "error") {
+                    const err = args[0];
+                    reject(err);
+                    return;
+                }
+                switch (args.length) {
+                    case 0:
+                        resolve(undefined);
+                        break;
+                    case 1:
+                        resolve(args[0]);
+                        break;
+                    default:
+                        resolve(args);
+                        break;
+                }
             });
         });
     }
@@ -328,17 +313,15 @@ let FileSystem = FileSystem_1 = class FileSystem {
     symlink(sourcePath, destinationPath, type) {
         fs.symlinkSync(sourcePath, destinationPath, type);
     }
-    setCurrentUserAsOwner(path, owner) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const $childProcess = this.$injector.resolve("childProcess");
-            if (!this.$injector.resolve("$hostInfo").isWindows) {
-                const chown = $childProcess.spawn("chown", ["-R", owner, path], {
-                    stdio: "ignore",
-                    detached: true,
-                });
-                yield this.futureFromEvent(chown, "close");
-            }
-        });
+    async setCurrentUserAsOwner(path, owner) {
+        const $childProcess = this.$injector.resolve("childProcess");
+        if (!this.$injector.resolve("$hostInfo").isWindows) {
+            const chown = $childProcess.spawn("chown", ["-R", owner, path], {
+                stdio: "ignore",
+                detached: true,
+            });
+            await this.futureFromEvent(chown, "close");
+        }
     }
     enumerateFilesInDirectorySync(directoryPath, filterCallback, opts, foundFiles) {
         foundFiles = foundFiles || [];
@@ -374,35 +357,31 @@ let FileSystem = FileSystem_1 = class FileSystem {
         }
         return foundFiles;
     }
-    getFileShasum(fileName, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const algorithm = (options && options.algorithm) || "sha1";
-                const encoding = (options && options.encoding) || "hex";
-                const logger = this.$injector.resolve("$logger");
-                const shasumData = crypto.createHash(algorithm);
-                const fileStream = this.createReadStream(fileName);
-                fileStream.on("data", (data) => {
-                    shasumData.update(data);
-                });
-                fileStream.on("end", () => {
-                    const shasum = shasumData.digest(encoding);
-                    logger.trace(`Shasum of file ${fileName} is ${shasum}`);
-                    resolve(shasum);
-                });
-                fileStream.on("error", (err) => {
-                    reject(err);
-                });
+    async getFileShasum(fileName, options) {
+        return new Promise((resolve, reject) => {
+            const algorithm = (options && options.algorithm) || "sha1";
+            const encoding = (options && options.encoding) || "hex";
+            const logger = this.$injector.resolve("$logger");
+            const shasumData = crypto.createHash(algorithm);
+            const fileStream = this.createReadStream(fileName);
+            fileStream.on("data", (data) => {
+                shasumData.update(data);
+            });
+            fileStream.on("end", () => {
+                const shasum = shasumData.digest(encoding);
+                logger.trace(`Shasum of file ${fileName} is ${shasum}`);
+                resolve(shasum);
+            });
+            fileStream.on("error", (err) => {
+                reject(err);
             });
         });
     }
-    readStdin() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                let buffer = "";
-                process.stdin.on("data", (data) => (buffer += data));
-                process.stdin.on("end", () => resolve(buffer));
-            });
+    async readStdin() {
+        return new Promise((resolve, reject) => {
+            let buffer = "";
+            process.stdin.on("data", (data) => (buffer += data));
+            process.stdin.on("end", () => resolve(buffer));
         });
     }
     rm(options, ...files) {
@@ -433,9 +412,9 @@ let FileSystem = FileSystem_1 = class FileSystem {
             : FileSystem_1.DEFAULT_INDENTATION_CHARACTER;
     }
 };
+exports.FileSystem = FileSystem;
 FileSystem.DEFAULT_INDENTATION_CHARACTER = "\t";
 FileSystem.JSON_OBJECT_REGEXP = new RegExp(`{\\r*\\n*(\\W*)"`, "m");
-FileSystem = FileSystem_1 = __decorate([
+exports.FileSystem = FileSystem = FileSystem_1 = __decorate([
     injector.register("fs")
 ], FileSystem);
-exports.FileSystem = FileSystem;

package/lib/common/header.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printHeader = void 0;
+exports.printHeader = printHeader;
 const color_1 = require("../color");
 const yok_1 = require("./yok");
 function printHeader() {
@@ -27,4 +27,3 @@ function printHeader() {
     console.info("  " + tagLine + " ".repeat(width - tagLineLength) + color_1.color.dim("│"));
     console.info("  " + color_1.color.dim("└" + "─".repeat(width - 1) + "┘"));
 }
-exports.printHeader = printHeader;