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

package/lib/services/terminal-spinner-service.js

@@ -1,27 +1,40 @@
 "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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TerminalSpinnerService = void 0;
-const ora_1 = require("ora");
+const ora = require("ora");
 const yok_1 = require("../common/yok");
 class TerminalSpinnerService {
     createSpinner(spinnerOptions = {}) {
+        // @ts-expect-error - options are readonly, however we still want to override them before passing them on...
         spinnerOptions.stream = spinnerOptions.stream || process.stdout;
-        return (0, ora_1.default)(spinnerOptions);
+        return ora(spinnerOptions);
     }
-    async execute(spinnerOptions, action) {
-        const spinner = this.createSpinner(spinnerOptions);
-        spinner.start();
-        let result = null;
-        try {
-            result = await action();
-        }
-        catch (err) {
-            spinner.fail();
-            return null;
-        }
-        spinner.succeed();
-        return result;
+    execute(spinnerOptions, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spinner = this.createSpinner(spinnerOptions);
+            spinner.start();
+            let result = null;
+            try {
+                result = yield action();
+            }
+            catch (err) {
+                spinner.fail();
+                return null;
+            }
+            spinner.succeed();
+            return result;
+        });
     }
 }
 exports.TerminalSpinnerService = TerminalSpinnerService;
 yok_1.injector.register("terminalSpinnerService", TerminalSpinnerService);
+//# sourceMappingURL=terminal-spinner-service.js.map

package/lib/services/test-execution-service.js

@@ -1,4 +1,13 @@
 "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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestExecutionService = void 0;
 const constants = require("../constants");
@@ -20,70 +29,79 @@ class TestExecutionService {
         this.$childProcess = $childProcess;
         this.allowedParameters = [];
     }
-    async startKarmaServer(platform, liveSyncInfo, deviceDescriptors) {
-        platform = platform.toLowerCase();
-        this.platform = platform;
-        const projectData = this.$projectDataService.getProjectData(liveSyncInfo.projectDir);
-        await this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);
-        const karmaConfig = this.getKarmaConfiguration(platform, projectData);
-        const karmaRunner = this.$childProcess.spawn(process.execPath, [path.join(__dirname, "karma-execution.js")], { stdio: ["inherit", "inherit", "inherit", "ipc"] });
-        const launchKarmaTests = async (karmaData) => {
-            this.$logger.trace("## Unit-testing: Parent process received message", karmaData);
-            let port;
-            if (karmaData.url) {
-                port = karmaData.url.port;
-                const socketIoJsUrl = `http://${karmaData.url.host}/socket.io/socket.io.js`;
-                const socketIoJs = (await this.$httpClient.httpRequest(socketIoJsUrl))
-                    .body;
-                this.$fs.writeFile(path.join(liveSyncInfo.projectDir, TestExecutionService.SOCKETIO_JS_FILE_NAME), JSON.parse(socketIoJs));
-            }
-            if (karmaData.launcherConfig) {
-                const configOptions = JSON.parse(karmaData.launcherConfig);
-                const configJs = this.generateConfig(port, configOptions);
-                this.$fs.writeFile(path.join(liveSyncInfo.projectDir, TestExecutionService.CONFIG_FILE_NAME), configJs);
-            }
-            await this.$runController.run({
-                liveSyncInfo,
-                deviceDescriptors,
-            });
-        };
-        karmaRunner.on("message", (karmaData) => {
-            this.$logger.trace(`The received message from karma is: `, karmaData);
-            if (!karmaData.launcherConfig && !karmaData.url) {
-                return;
-            }
-            launchKarmaTests(karmaData).catch((result) => {
-                this.$logger.error(result);
-                process.exit(130);
-            });
-        });
-        return new Promise((resolve, reject) => {
-            karmaRunner.on("exit", (exitCode) => {
-                if (exitCode !== 0) {
-                    const testError = new Error("Test run failed.");
-                    reject(testError);
+    startKarmaServer(platform, liveSyncInfo, deviceDescriptors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            platform = platform.toLowerCase();
+            this.platform = platform;
+            const projectData = this.$projectDataService.getProjectData(liveSyncInfo.projectDir);
+            // We need the dependencies installed here, so we can start the Karma server.
+            yield this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);
+            const karmaConfig = this.getKarmaConfiguration(platform, projectData);
+            // In case you want to debug the unit test runner, add "--inspect-brk=<port>" as a first element in the array of args.
+            const karmaRunner = this.$childProcess.spawn(process.execPath, [path.join(__dirname, "karma-execution.js")], { stdio: ["inherit", "inherit", "inherit", "ipc"] });
+            const launchKarmaTests = (karmaData) => __awaiter(this, void 0, void 0, function* () {
+                this.$logger.trace("## Unit-testing: Parent process received message", karmaData);
+                let port;
+                if (karmaData.url) {
+                    port = karmaData.url.port;
+                    const socketIoJsUrl = `http://${karmaData.url.host}/socket.io/socket.io.js`;
+                    const socketIoJs = (yield this.$httpClient.httpRequest(socketIoJsUrl))
+                        .body;
+                    this.$fs.writeFile(path.join(liveSyncInfo.projectDir, TestExecutionService.SOCKETIO_JS_FILE_NAME), JSON.parse(socketIoJs));
                 }
-                else {
-                    resolve();
+                if (karmaData.launcherConfig) {
+                    const configOptions = JSON.parse(karmaData.launcherConfig);
+                    const configJs = this.generateConfig(port, configOptions);
+                    this.$fs.writeFile(path.join(liveSyncInfo.projectDir, TestExecutionService.CONFIG_FILE_NAME), configJs);
                 }
+                // Prepare the project AFTER the TestExecutionService.CONFIG_FILE_NAME file is created in node_modules
+                // so it will be sent to device.
+                yield this.$runController.run({
+                    liveSyncInfo,
+                    deviceDescriptors,
+                });
+            });
+            karmaRunner.on("message", (karmaData) => {
+                this.$logger.trace(`The received message from karma is: `, karmaData);
+                if (!karmaData.launcherConfig && !karmaData.url) {
+                    return;
+                }
+                launchKarmaTests(karmaData).catch((result) => {
+                    this.$logger.error(result);
+                    process.exit(130 /* ErrorCodes.KARMA_FAIL */);
+                });
+            });
+            return new Promise((resolve, reject) => {
+                karmaRunner.on("exit", (exitCode) => {
+                    if (exitCode !== 0) {
+                        //End our process with a non-zero exit code
+                        const testError = new Error("Test run failed.");
+                        reject(testError);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+                karmaRunner.send({ karmaConfig: karmaConfig });
             });
-            karmaRunner.send({ karmaConfig: karmaConfig });
         });
     }
-    async canStartKarmaServer(projectData) {
-        let canStartKarmaServer = true;
-        const requiredDependencies = ["@nativescript/unit-test-runner"];
-        _.each(requiredDependencies, (dep) => {
-            if (!projectData.dependencies[dep] && !projectData.devDependencies[dep]) {
-                canStartKarmaServer = false;
-                return;
-            }
-        });
-        const pathToKarma = (0, package_path_helper_1.resolvePackagePath)("karma", {
-            paths: [projectData.projectDir],
+    canStartKarmaServer(projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let canStartKarmaServer = true;
+            const requiredDependencies = ["@nativescript/unit-test-runner"]; // we need @nativescript/unit-test-runner at the local level because of hooks!
+            _.each(requiredDependencies, (dep) => {
+                if (!projectData.dependencies[dep] && !projectData.devDependencies[dep]) {
+                    canStartKarmaServer = false;
+                    return;
+                }
+            });
+            const pathToKarma = (0, package_path_helper_1.resolvePackagePath)("karma", {
+                paths: [projectData.projectDir],
+            });
+            canStartKarmaServer = canStartKarmaServer && !!pathToKarma;
+            return canStartKarmaServer;
         });
-        canStartKarmaServer = canStartKarmaServer && !!pathToKarma;
-        return canStartKarmaServer;
     }
     generateConfig(port, options) {
         const nics = os.networkInterfaces();
@@ -121,6 +139,7 @@ class TestExecutionService {
             karmaConfig.logLevel = "DEBUG";
         }
         if (!this.$options.watch) {
+            // Setting singleRun to true will automatically start the tests when new browser (device in our case) is registered in karma.
             karmaConfig.singleRun = true;
         }
         if (this.$options.debugBrk) {
@@ -135,7 +154,8 @@ class TestExecutionService {
         return karmaConfig;
     }
 }
-exports.TestExecutionService = TestExecutionService;
 TestExecutionService.CONFIG_FILE_NAME = `node_modules/${constants.TEST_RUNNER_NAME}/config.js`;
 TestExecutionService.SOCKETIO_JS_FILE_NAME = `node_modules/${constants.TEST_RUNNER_NAME}/socket.io.js`;
+exports.TestExecutionService = TestExecutionService;
 yok_1.injector.register("testExecutionService", TestExecutionService);
+//# sourceMappingURL=test-execution-service.js.map

package/lib/services/test-initialization-service.js

@@ -30,10 +30,13 @@ class TestInitializationService {
             if (!dependencyVersion) {
                 this.$errors.fail(`'${dependency}' is not a registered dependency.`);
             }
-            return { ...dependency, version: dependencyVersion };
+            return Object.assign(Object.assign({}, dependency), { version: dependencyVersion });
         });
         return targetFrameworkDependencies;
     }
+    /**
+     * This method is used from test-init.md file so it is not allowed to use "this" inside the method's body.
+     */
     getFrameworkNames() {
         const configsPath = path.join(__dirname, "..", "..", "config");
         const dependenciesPath = path.join(configsPath, "test-dependencies.json");
@@ -44,11 +47,12 @@ class TestInitializationService {
         return frameworks;
     }
 }
-exports.TestInitializationService = TestInitializationService;
 __decorate([
     (0, decorators_1.cache)()
 ], TestInitializationService.prototype, "getDependencies", null);
 __decorate([
     (0, decorators_1.cache)()
 ], TestInitializationService.prototype, "getFrameworkNames", null);
+exports.TestInitializationService = TestInitializationService;
 yok_1.injector.register("testInitializationService", TestInitializationService);
+//# sourceMappingURL=test-initialization-service.js.map

package/lib/services/timeline-profiler-service.js

@@ -93,8 +93,9 @@ class TimelineProfilerService {
         process.exit();
     }
 }
-exports.TimelineProfilerService = TimelineProfilerService;
 __decorate([
     (0, decorators_1.cache)()
 ], TimelineProfilerService.prototype, "isEnabled", null);
+exports.TimelineProfilerService = TimelineProfilerService;
 yok_1.injector.register("timelineProfilerService", TimelineProfilerService);
+//# sourceMappingURL=timeline-profiler-service.js.map

package/lib/services/user-settings-service.js

@@ -32,3 +32,4 @@ class UserSettingsService {
 }
 exports.UserSettingsService = UserSettingsService;
 yok_1.injector.register("userSettingsService", UserSettingsService);
+//# sourceMappingURL=user-settings-service.js.map

package/lib/services/versions-service.js

@@ -1,4 +1,13 @@
 "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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VersionInformationType = void 0;
 const constants = require("../constants");
@@ -12,7 +21,7 @@ var VersionInformationType;
     VersionInformationType["UpToDate"] = "UpToDate";
     VersionInformationType["UpdateAvailable"] = "UpdateAvailable";
     VersionInformationType["NotInstalled"] = "NotInstalled";
-})(VersionInformationType || (exports.VersionInformationType = VersionInformationType = {}));
+})(VersionInformationType = exports.VersionInformationType || (exports.VersionInformationType = {}));
 class VersionsService {
     constructor($fs, $packageInstallationManager, $injector, $logger, $staticConfig, $pluginsService, $projectDataService, $terminalSpinnerService) {
         this.$fs = $fs;
@@ -25,136 +34,147 @@ class VersionsService {
         this.$terminalSpinnerService = $terminalSpinnerService;
         this.projectData = this.getProjectData();
     }
-    async getNativescriptCliVersion() {
-        const currentCliVersion = this.$staticConfig.version;
-        const latestCliVersion = await this.$packageInstallationManager.getLatestVersion(constants.NATIVESCRIPT_KEY_NAME);
-        return {
-            componentName: constants.NATIVESCRIPT_KEY_NAME,
-            currentVersion: currentCliVersion,
-            latestVersion: latestCliVersion,
-        };
+    getNativescriptCliVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentCliVersion = this.$staticConfig.version;
+            const latestCliVersion = yield this.$packageInstallationManager.getLatestVersion(constants.NATIVESCRIPT_KEY_NAME);
+            return {
+                componentName: constants.NATIVESCRIPT_KEY_NAME,
+                currentVersion: currentCliVersion,
+                latestVersion: latestCliVersion,
+            };
+        });
     }
-    async getTnsCoreModulesVersion() {
-        const latestTnsCoreModulesVersion = await this.$packageInstallationManager.getLatestVersion(constants.TNS_CORE_MODULES_NAME);
-        const nativescriptCoreModulesInfo = {
-            componentName: constants.TNS_CORE_MODULES_NAME,
-            latestVersion: latestTnsCoreModulesVersion,
-        };
-        const versionInformations = [];
-        if (this.projectData) {
-            const nodeModulesPath = path.join(this.projectData.projectDir, constants.NODE_MODULES_FOLDER_NAME);
-            const scopedPackagePath = path.join(nodeModulesPath, constants.SCOPED_TNS_CORE_MODULES);
-            const tnsCoreModulesPath = path.join(nodeModulesPath, constants.TNS_CORE_MODULES_NAME);
-            const dependsOnNonScopedPackage = !!this.projectData.dependencies[constants.TNS_CORE_MODULES_NAME];
-            const dependsOnScopedPackage = !!this.projectData.dependencies[constants.SCOPED_TNS_CORE_MODULES];
-            if (!this.$fs.exists(nodeModulesPath) ||
-                (dependsOnNonScopedPackage && !this.$fs.exists(tnsCoreModulesPath)) ||
-                (dependsOnScopedPackage && !this.$fs.exists(scopedPackagePath))) {
-                await this.$pluginsService.ensureAllDependenciesAreInstalled(this.projectData);
+    getTnsCoreModulesVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latestTnsCoreModulesVersion = yield this.$packageInstallationManager.getLatestVersion(constants.TNS_CORE_MODULES_NAME);
+            const nativescriptCoreModulesInfo = {
+                componentName: constants.TNS_CORE_MODULES_NAME,
+                latestVersion: latestTnsCoreModulesVersion,
+            };
+            const versionInformations = [];
+            if (this.projectData) {
+                const nodeModulesPath = path.join(this.projectData.projectDir, constants.NODE_MODULES_FOLDER_NAME);
+                const scopedPackagePath = path.join(nodeModulesPath, constants.SCOPED_TNS_CORE_MODULES);
+                const tnsCoreModulesPath = path.join(nodeModulesPath, constants.TNS_CORE_MODULES_NAME);
+                const dependsOnNonScopedPackage = !!this.projectData.dependencies[constants.TNS_CORE_MODULES_NAME];
+                const dependsOnScopedPackage = !!this.projectData.dependencies[constants.SCOPED_TNS_CORE_MODULES];
+                // ensure the dependencies are installed, so we can get their actual versions from node_modules
+                if (!this.$fs.exists(nodeModulesPath) ||
+                    (dependsOnNonScopedPackage && !this.$fs.exists(tnsCoreModulesPath)) ||
+                    (dependsOnScopedPackage && !this.$fs.exists(scopedPackagePath))) {
+                    yield this.$pluginsService.ensureAllDependenciesAreInstalled(this.projectData);
+                }
+                if (dependsOnNonScopedPackage && this.$fs.exists(tnsCoreModulesPath)) {
+                    const currentTnsCoreModulesVersion = this.$fs.readJson(path.join(tnsCoreModulesPath, constants.PACKAGE_JSON_FILE_NAME)).version;
+                    nativescriptCoreModulesInfo.currentVersion = currentTnsCoreModulesVersion;
+                    versionInformations.push(nativescriptCoreModulesInfo);
+                }
+                if (dependsOnScopedPackage && this.$fs.exists(scopedPackagePath)) {
+                    const scopedModulesInformation = {
+                        componentName: constants.SCOPED_TNS_CORE_MODULES,
+                        latestVersion: yield this.$packageInstallationManager.getLatestVersion(constants.SCOPED_TNS_CORE_MODULES),
+                    };
+                    const currentScopedPackageVersion = this.$fs.readJson(path.join(scopedPackagePath, constants.PACKAGE_JSON_FILE_NAME)).version;
+                    scopedModulesInformation.currentVersion = currentScopedPackageVersion;
+                    versionInformations.push(scopedModulesInformation);
+                }
             }
-            if (dependsOnNonScopedPackage && this.$fs.exists(tnsCoreModulesPath)) {
-                const currentTnsCoreModulesVersion = this.$fs.readJson(path.join(tnsCoreModulesPath, constants.PACKAGE_JSON_FILE_NAME)).version;
-                nativescriptCoreModulesInfo.currentVersion = currentTnsCoreModulesVersion;
+            else {
                 versionInformations.push(nativescriptCoreModulesInfo);
             }
-            if (dependsOnScopedPackage && this.$fs.exists(scopedPackagePath)) {
-                const scopedModulesInformation = {
-                    componentName: constants.SCOPED_TNS_CORE_MODULES,
-                    latestVersion: await this.$packageInstallationManager.getLatestVersion(constants.SCOPED_TNS_CORE_MODULES),
-                };
-                const currentScopedPackageVersion = this.$fs.readJson(path.join(scopedPackagePath, constants.PACKAGE_JSON_FILE_NAME)).version;
-                scopedModulesInformation.currentVersion = currentScopedPackageVersion;
-                versionInformations.push(scopedModulesInformation);
-            }
-        }
-        else {
-            versionInformations.push(nativescriptCoreModulesInfo);
-        }
-        return versionInformations;
-    }
-    async getRuntimesVersions(platform) {
-        const iosRuntime = this.$projectDataService.getRuntimePackage(this.projectData.projectDir, "ios");
-        const androidRuntime = this.$projectDataService.getRuntimePackage(this.projectData.projectDir, "android");
-        let runtimes = [];
-        if (!platform) {
-            runtimes = [iosRuntime, androidRuntime];
-        }
-        else if (platform === "ios") {
-            runtimes.push(iosRuntime);
-        }
-        else if (platform === "android") {
-            runtimes.push(androidRuntime);
-        }
-        const runtimesVersions = await Promise.all(runtimes.map(async (runtime) => {
-            const latestVersion = await this.$packageInstallationManager.getLatestVersion(runtime.name);
-            const runtimeInformation = {
-                componentName: runtime.name,
-                currentVersion: runtime.version,
-                latestVersion,
-            };
-            return runtimeInformation;
-        }));
-        return runtimesVersions;
+            return versionInformations;
+        });
     }
-    async getAllComponentsVersions(platform) {
-        try {
-            let allComponents = [];
-            const nativescriptCliInformation = await this.getNativescriptCliVersion();
-            if (nativescriptCliInformation) {
-                allComponents.push(nativescriptCliInformation);
+    getRuntimesVersions(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const iosRuntime = this.$projectDataService.getRuntimePackage(this.projectData.projectDir, "ios" /* constants.PlatformTypes.ios */);
+            const androidRuntime = this.$projectDataService.getRuntimePackage(this.projectData.projectDir, "android" /* constants.PlatformTypes.android */);
+            let runtimes = [];
+            if (!platform) {
+                runtimes = [iosRuntime, androidRuntime];
             }
-            if (this.projectData) {
-                const nativescriptCoreModulesInformation = await this.getTnsCoreModulesVersion();
-                if (nativescriptCoreModulesInformation) {
-                    allComponents.push(...nativescriptCoreModulesInformation);
-                }
-                const runtimesVersions = await this.getRuntimesVersions(platform);
-                allComponents = allComponents.concat(runtimesVersions);
+            else if (platform === "ios" /* PlatformTypes.ios */) {
+                runtimes.push(iosRuntime);
             }
-            return allComponents.map((componentInformation) => {
-                if (componentInformation.currentVersion) {
-                    if (this.hasUpdate(componentInformation)) {
-                        componentInformation.type = VersionInformationType.UpdateAvailable;
-                        componentInformation.message = `${VersionsService.UPDATE_AVAILABLE_MESSAGE} for component ${componentInformation.componentName}. Your current version is ${componentInformation.currentVersion} and the latest available version is ${componentInformation.latestVersion}.`;
+            else if (platform === "android" /* PlatformTypes.android */) {
+                runtimes.push(androidRuntime);
+            }
+            const runtimesVersions = yield Promise.all(runtimes.map((runtime) => __awaiter(this, void 0, void 0, function* () {
+                const latestVersion = yield this.$packageInstallationManager.getLatestVersion(runtime.name);
+                const runtimeInformation = {
+                    componentName: runtime.name,
+                    currentVersion: runtime.version,
+                    latestVersion,
+                };
+                return runtimeInformation;
+            })));
+            return runtimesVersions;
+        });
+    }
+    getAllComponentsVersions(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let allComponents = [];
+                const nativescriptCliInformation = yield this.getNativescriptCliVersion();
+                if (nativescriptCliInformation) {
+                    allComponents.push(nativescriptCliInformation);
+                }
+                if (this.projectData) {
+                    const nativescriptCoreModulesInformation = yield this.getTnsCoreModulesVersion();
+                    if (nativescriptCoreModulesInformation) {
+                        allComponents.push(...nativescriptCoreModulesInformation);
+                    }
+                    const runtimesVersions = yield this.getRuntimesVersions(platform);
+                    allComponents = allComponents.concat(runtimesVersions);
+                }
+                return allComponents.map((componentInformation) => {
+                    if (componentInformation.currentVersion) {
+                        if (this.hasUpdate(componentInformation)) {
+                            componentInformation.type = VersionInformationType.UpdateAvailable;
+                            componentInformation.message = `${VersionsService.UPDATE_AVAILABLE_MESSAGE} for component ${componentInformation.componentName}. Your current version is ${componentInformation.currentVersion} and the latest available version is ${componentInformation.latestVersion}.`;
+                        }
+                        else {
+                            componentInformation.type = VersionInformationType.UpToDate;
+                            componentInformation.message = `Component ${componentInformation.componentName} has ${componentInformation.currentVersion} version and is ${VersionsService.UP_TO_DATE_MESSAGE}.`;
+                        }
                     }
                     else {
-                        componentInformation.type = VersionInformationType.UpToDate;
-                        componentInformation.message = `Component ${componentInformation.componentName} has ${componentInformation.currentVersion} version and is ${VersionsService.UP_TO_DATE_MESSAGE}.`;
+                        componentInformation.type = VersionInformationType.NotInstalled;
+                        componentInformation.message = `Component ${componentInformation.componentName} is ${VersionsService.NOT_INSTALLED_MESSAGE}.`;
                     }
-                }
-                else {
-                    componentInformation.type = VersionInformationType.NotInstalled;
-                    componentInformation.message = `Component ${componentInformation.componentName} is ${VersionsService.NOT_INSTALLED_MESSAGE}.`;
-                }
-                return componentInformation;
-            });
-        }
-        catch (error) {
-            this.$logger.trace("Error while trying to get component information. Error is: ", error);
-            return [];
-        }
+                    return componentInformation;
+                });
+            }
+            catch (error) {
+                this.$logger.trace("Error while trying to get component information. Error is: ", error);
+                return [];
+            }
+        });
     }
-    async printVersionsInformation(platform) {
-        const versionsInformation = await this.$terminalSpinnerService.execute({
-            text: `Getting NativeScript components versions information...`,
-        }, () => this.getAllComponentsVersions(platform));
-        if (!helpers.isInteractive()) {
-            versionsInformation.map((componentInformation) => this.$logger.info(componentInformation.message));
-        }
-        _.forEach(versionsInformation, (componentInformation) => {
-            const spinner = this.$terminalSpinnerService.createSpinner();
-            spinner.text = componentInformation.message;
-            switch (componentInformation.type) {
-                case VersionInformationType.UpToDate:
-                    spinner.succeed();
-                    break;
-                case VersionInformationType.UpdateAvailable:
-                    spinner.warn();
-                    break;
-                case VersionInformationType.NotInstalled:
-                    spinner.fail();
-                    break;
+    printVersionsInformation(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const versionsInformation = yield this.$terminalSpinnerService.execute({
+                text: `Getting NativeScript components versions information...`,
+            }, () => this.getAllComponentsVersions(platform));
+            if (!helpers.isInteractive()) {
+                versionsInformation.map((componentInformation) => this.$logger.info(componentInformation.message));
             }
+            _.forEach(versionsInformation, (componentInformation) => {
+                const spinner = this.$terminalSpinnerService.createSpinner();
+                spinner.text = componentInformation.message;
+                switch (componentInformation.type) {
+                    case VersionInformationType.UpToDate:
+                        spinner.succeed();
+                        break;
+                    case VersionInformationType.UpdateAvailable:
+                        spinner.warn();
+                        break;
+                    case VersionInformationType.NotInstalled:
+                        spinner.fail();
+                        break;
+                }
+            });
         });
     }
     getProjectData() {
@@ -175,3 +195,4 @@ VersionsService.UP_TO_DATE_MESSAGE = "up to date";
 VersionsService.UPDATE_AVAILABLE_MESSAGE = "Update available";
 VersionsService.NOT_INSTALLED_MESSAGE = "not installed";
 yok_1.injector.register("versionsService", VersionsService);
+//# sourceMappingURL=versions-service.js.map

package/lib/services/watch-ignore-list-service.js

@@ -18,3 +18,4 @@ class WatchIgnoreListService {
 }
 exports.WatchIgnoreListService = WatchIgnoreListService;
 yok_1.injector.register("watchIgnoreListService", WatchIgnoreListService);
+//# sourceMappingURL=watch-ignore-list-service.js.map