nativescript 8.9.0-dev.1 → 8.9.0-dev.2

package/lib/common/errors.js

@@ -5,9 +5,17 @@ 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 = void 0;
-exports.installUncaughtExceptionListener = installUncaughtExceptionListener;
+exports.Errors = exports.installUncaughtExceptionListener = void 0;
 const util = require("util");
 const path = require("path");
 const _ = require("lodash");
@@ -15,97 +23,109 @@ const source_map_1 = require("source-map");
 const helpers_1 = require("./helpers");
 const decorators_1 = require("./decorators");
 const yok_1 = require("./yok");
+// we need this to overwrite .stack property (read-only in Error)
 function Exception() {
+    /* intentionally left blank */
 }
 Exception.prototype = new Error();
-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;
-        }
-        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);
+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 util.format("    at %s (%s:%s:%s)", functionName, fileName, line, column);
+            return line;
         });
-    }));
-    let outputMessage = remapped.join("\n");
-    if (outputMessage.indexOf(error.message) === -1) {
-        outputMessage = outputMessage.replace(/Error/, "Error: " + error.message);
-    }
-    return outputMessage;
+        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) {
+            // when fibers throw error in node 0.12.x, the stack does NOT contain the message
+            outputMessage = outputMessage.replace(/Error/, "Error: " + error.message);
+        }
+        return outputMessage;
+    });
 }
 function installUncaughtExceptionListener(actionOnException) {
-    const handler = async (err) => {
+    const handler = (err) => __awaiter(this, void 0, void 0, function* () {
         try {
             let callstack = err.stack;
             if (callstack) {
                 try {
-                    callstack = await resolveCallStack(err);
+                    callstack = yield resolveCallStack(err);
                 }
                 catch (err) {
                     console.error("Error while resolving callStack:", err);
                 }
             }
             console.error(callstack || err.toString());
-            await tryTrackException(err, yok_1.injector);
+            yield tryTrackException(err, yok_1.injector);
             if (actionOnException) {
                 actionOnException();
             }
         }
         catch (err) {
-            process.exit(131);
+            // In case the handler throws error and we do not catch it, we'll go in infinite loop of unhandled rejections.
+            // We cannot do anything here as even `console.error` may fail. So just exit the process.
+            process.exit(131 /* ErrorCodes.UNHANDLED_REJECTION_FAILURE */);
         }
-    };
+    });
     process.on("uncaughtException", handler);
     process.on("unhandledRejection", handler);
 }
-async function tryTrackException(error, localInjector) {
-    let disableAnalytics;
-    try {
-        disableAnalytics = localInjector.resolve("staticConfig").disableAnalytics;
-    }
-    catch (err) {
-        disableAnalytics = true;
-    }
-    if (!disableAnalytics) {
+exports.installUncaughtExceptionListener = installUncaughtExceptionListener;
+function tryTrackException(error, localInjector) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let disableAnalytics;
         try {
-            const analyticsService = localInjector.resolve("analyticsService");
-            await analyticsService.trackException(error, error.message);
+            disableAnalytics = localInjector.resolve("staticConfig").disableAnalytics;
         }
-        catch (e) {
-            console.error("Error while reporting exception: " + e);
+        catch (err) {
+            // We should get here only in our unit tests.
+            disableAnalytics = true;
         }
-    }
+        if (!disableAnalytics) {
+            try {
+                const analyticsService = localInjector.resolve("analyticsService");
+                yield analyticsService.trackException(error, error.message);
+            }
+            catch (e) {
+                // Do not replace with logger due to cyclic dependency
+                console.error("Error while reporting exception: " + e);
+            }
+        }
+    });
 }
 class Errors {
     constructor($injector) {
@@ -140,43 +160,47 @@ class Errors {
             exception.message = $messagesService.getMessage.apply($messagesService, [opts.formatStr].concat(argsArray));
         }
         catch (err) {
+            // Ignore
         }
         exception.stack = new Error(exception.message).stack;
-        exception.errorCode = opts.errorCode || 127;
+        exception.errorCode = opts.errorCode || 127 /* ErrorCodes.UNKNOWN */;
         exception.suggestCommandHelp = suggestCommandHelp;
         exception.proxyAuthenticationRequired = !!opts.proxyAuthenticationRequired;
         exception.printOnStdout = opts.printOnStdout;
         this.$injector.resolve("logger").trace(opts.formatStr);
         throw exception;
     }
-    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);
-            }
-            else {
-                logger.error(message);
+    beginCommand(action, printCommandHelpSuggestion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield action();
             }
-            if (ex.suggestCommandHelp) {
-                await printCommandHelpSuggestion();
+            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 /* ErrorCodes.UNKNOWN */);
             }
-            await tryTrackException(ex, this.$injector);
-            process.exit(_.isNumber(ex.errorCode) ? ex.errorCode : 127);
-        }
+        });
     }
+    // If you want to activate this function, start Node with flags --nouse_idle_notification and --expose_gc
     verifyHeap(message) {
         if (global.gc) {
             console.log("verifyHeap: '%s'", message);
@@ -184,8 +208,9 @@ 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);
+//# sourceMappingURL=errors.js.map

package/lib/common/file-system.js

@@ -5,6 +5,15 @@ 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;
@@ -18,71 +27,78 @@ const shelljs = require("shelljs");
 const helpers_1 = require("./helpers");
 const constants_1 = require("../constants");
 const os_1 = require("os");
-const detect_newline_1 = require("detect-newline");
+const detectNewline = require("detect-newline");
 const archiver_1 = require("archiver");
+const stringifyPackage = require("stringify-package");
+// TODO: Add .d.ts for mkdirp module (or use it from @types repo).
 const mkdirp = require("mkdirp");
 let FileSystem = FileSystem_1 = class FileSystem {
     constructor($injector) {
         this.$injector = $injector;
     }
-    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();
+    zipFiles(zipFile, files, zipPathCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //we are resolving it here instead of in the constructor, because config has dependency on file system and config shouldn't require logger
+            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();
             });
-            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);
     }
-    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,
+    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"; // darwin unzip is info-zip
+            }
+            else if ($hostInfo.isLinux) {
+                proc = "unzip"; // linux unzip is info-zip
+            }
+            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,
+            });
         });
     }
     findFileCaseInsensitive(file) {
@@ -106,6 +122,7 @@ let FileSystem = FileSystem_1 = class FileSystem {
         }
         catch (err) {
             if (err && err.code !== "ENOENT") {
+                // ignore "file doesn't exist" error
                 throw err;
             }
         }
@@ -144,6 +161,7 @@ let FileSystem = FileSystem_1 = class FileSystem {
                 }
             });
             if (root) {
+                // console.log("root", paths);
                 return Array.from(paths.values()).reduce((sum, current) => sum + current, 0);
             }
         };
@@ -154,26 +172,28 @@ let FileSystem = FileSystem_1 = class FileSystem {
             return 0;
         }
     }
-    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;
-                }
+    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;
+                    }
+                });
             });
         });
     }
@@ -216,6 +236,8 @@ let FileSystem = FileSystem_1 = class FileSystem {
     writeFile(filename, data, encoding) {
         this.createDirectory((0, path_1.dirname)(filename));
         if (!data) {
+            // node 14 will no longer coerce unsupported input to strings anymore.
+            // clean any null or undefined data
             data = "";
         }
         fs.writeFileSync(filename, data, { encoding: encoding });
@@ -232,9 +254,9 @@ let FileSystem = FileSystem_1 = class FileSystem {
             let newline = os_1.EOL;
             if (fs.existsSync(filename)) {
                 const existingFile = this.readText(filename);
-                newline = (0, detect_newline_1.detectNewline)(existingFile);
+                newline = detectNewline(existingFile);
             }
-            stringifiedData = JSON.stringify(data, null, space).concat(newline);
+            stringifiedData = stringifyPackage(data, space, newline);
         }
         else {
             stringifiedData = JSON.stringify(data, null, space);
@@ -246,6 +268,8 @@ let FileSystem = FileSystem_1 = class FileSystem {
             return;
         }
         this.createDirectory((0, path_1.dirname)(destinationFileName));
+        // MobileApplication.app is resolved as a directory on Mac,
+        // therefore we need to copy it recursively as it's not a single file.
         shelljs.cp("-rf", sourceFileName, destinationFileName);
         const err = shelljs.error();
         if (err) {
@@ -312,16 +336,20 @@ let FileSystem = FileSystem_1 = class FileSystem {
     symlink(sourcePath, destinationPath, type) {
         fs.symlinkSync(sourcePath, destinationPath, type);
     }
-    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");
-        }
+    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");
+            }
+            // nothing to do on Windows, as chown does not work on this platform
+        });
     }
+    // filterCallback: function(path: String, stat: fs.Stats): Boolean
     enumerateFilesInDirectorySync(directoryPath, filterCallback, opts, foundFiles) {
         foundFiles = foundFiles || [];
         if (!this.exists(directoryPath)) {
@@ -356,31 +384,35 @@ let FileSystem = FileSystem_1 = class FileSystem {
         }
         return foundFiles;
     }
-    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);
+    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 readStdin() {
-        return new Promise((resolve, reject) => {
-            let buffer = "";
-            process.stdin.on("data", (data) => (buffer += data));
-            process.stdin.on("end", () => resolve(buffer));
+    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));
+            });
         });
     }
     rm(options, ...files) {
@@ -411,9 +443,10 @@ 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");
-exports.FileSystem = FileSystem = FileSystem_1 = __decorate([
+FileSystem = FileSystem_1 = __decorate([
     injector.register("fs")
 ], FileSystem);
+exports.FileSystem = FileSystem;
+//# sourceMappingURL=file-system.js.map

package/lib/common/header.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printHeader = printHeader;
+exports.printHeader = void 0;
 const color_1 = require("../color");
 const yok_1 = require("./yok");
 function printHeader() {
@@ -13,11 +13,13 @@ function printHeader() {
         color_1.color.cyanBright.bold("{N} NativeScript "),
         color_1.color.whiteBright.bold("CLI"),
         color_1.color.dim(` [v${version}] `),
+        // color.dim("  │"),
     ].join("");
     const tagLine = [
         color_1.color.dim("│ "),
         color_1.color.dim(" → "),
         color_1.color.whiteBright.bold("Empower JavaScript with native APIs "),
+        // color.dim("  │"),
     ].join("");
     const headerLength = (0, color_1.stripColors)(header).length;
     const tagLineLength = (0, color_1.stripColors)(tagLine).length;
@@ -27,3 +29,5 @@ function printHeader() {
     console.info("  " + tagLine + " ".repeat(width - tagLineLength) + color_1.color.dim("│"));
     console.info("  " + color_1.color.dim("└" + "─".repeat(width - 1) + "┘"));
 }
+exports.printHeader = printHeader;
+//# sourceMappingURL=header.js.map