@akylas/nativescript-cli 8.8.2 → 8.8.4

package/lib/services/test-execution-service.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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestExecutionService = void 0;
 const constants = require("../constants");
@@ -29,74 +20,70 @@ class TestExecutionService {
         this.$childProcess = $childProcess;
         this.allowedParameters = [];
     }
-    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);
-            yield 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 = (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));
-                }
-                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);
-                }
-                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);
-                });
+    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,
             });
-            return new Promise((resolve, reject) => {
-                karmaRunner.on("exit", (exitCode) => {
-                    if (exitCode !== 0) {
-                        const testError = new Error("Test run failed.");
-                        reject(testError);
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-                karmaRunner.send({ karmaConfig: karmaConfig });
+        };
+        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);
             });
         });
-    }
-    canStartKarmaServer(projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let canStartKarmaServer = true;
-            const requiredDependencies = ["@nativescript/unit-test-runner"];
-            _.each(requiredDependencies, (dep) => {
-                if (!projectData.dependencies[dep] && !projectData.devDependencies[dep]) {
-                    canStartKarmaServer = false;
-                    return;
+        return new Promise((resolve, reject) => {
+            karmaRunner.on("exit", (exitCode) => {
+                if (exitCode !== 0) {
+                    const testError = new Error("Test run failed.");
+                    reject(testError);
+                }
+                else {
+                    resolve();
                 }
             });
-            const pathToKarma = (0, package_path_helper_1.resolvePackagePath)("karma", {
-                paths: [projectData.projectDir],
-            });
-            canStartKarmaServer = canStartKarmaServer && !!pathToKarma;
-            return canStartKarmaServer;
+            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 = canStartKarmaServer && !!pathToKarma;
+        return canStartKarmaServer;
     }
     generateConfig(port, options) {
         const nics = os.networkInterfaces();
@@ -148,7 +135,7 @@ 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);

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

@@ -30,7 +30,7 @@ class TestInitializationService {
             if (!dependencyVersion) {
                 this.$errors.fail(`'${dependency}' is not a registered dependency.`);
             }
-            return Object.assign(Object.assign({}, dependency), { version: dependencyVersion });
+            return { ...dependency, version: dependencyVersion };
         });
         return targetFrameworkDependencies;
     }
@@ -44,11 +44,11 @@ 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);

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

@@ -101,8 +101,8 @@ 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);

package/lib/services/versions-service.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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VersionInformationType = void 0;
 const constants = require("../constants");
@@ -21,7 +12,7 @@ var VersionInformationType;
     VersionInformationType["UpToDate"] = "UpToDate";
     VersionInformationType["UpdateAvailable"] = "UpdateAvailable";
     VersionInformationType["NotInstalled"] = "NotInstalled";
-})(VersionInformationType = exports.VersionInformationType || (exports.VersionInformationType = {}));
+})(VersionInformationType || (exports.VersionInformationType = VersionInformationType = {}));
 class VersionsService {
     constructor($fs, $packageInstallationManager, $injector, $logger, $staticConfig, $pluginsService, $projectDataService, $terminalSpinnerService) {
         this.$fs = $fs;
@@ -34,146 +25,136 @@ class VersionsService {
         this.$terminalSpinnerService = $terminalSpinnerService;
         this.projectData = this.getProjectData();
     }
-    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 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,
+        };
     }
-    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];
-                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);
-                }
+    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);
             }
-            else {
+            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);
             }
-            return versionInformations;
-        });
-    }
-    getRuntimesVersions(platform) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = 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,
+            if (dependsOnScopedPackage && this.$fs.exists(scopedPackagePath)) {
+                const scopedModulesInformation = {
+                    componentName: constants.SCOPED_TNS_CORE_MODULES,
+                    latestVersion: await this.$packageInstallationManager.getLatestVersion(constants.SCOPED_TNS_CORE_MODULES),
                 };
-                return runtimeInformation;
-            })));
-            return runtimesVersions;
-        });
+                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;
     }
-    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);
+    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;
+    }
+    async getAllComponentsVersions(platform) {
+        try {
+            let allComponents = [];
+            const nativescriptCliInformation = await this.getNativescriptCliVersion();
+            if (nativescriptCliInformation) {
+                allComponents.push(nativescriptCliInformation);
+            }
+            if (this.projectData) {
+                const nativescriptCoreModulesInformation = await this.getTnsCoreModulesVersion();
+                if (nativescriptCoreModulesInformation) {
+                    allComponents.push(...nativescriptCoreModulesInformation);
                 }
-                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}.`;
-                        }
+                const runtimesVersions = await 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.NotInstalled;
-                        componentInformation.message = `Component ${componentInformation.componentName} is ${VersionsService.NOT_INSTALLED_MESSAGE}.`;
+                        componentInformation.type = VersionInformationType.UpToDate;
+                        componentInformation.message = `Component ${componentInformation.componentName} has ${componentInformation.currentVersion} version and is ${VersionsService.UP_TO_DATE_MESSAGE}.`;
                     }
-                    return componentInformation;
-                });
-            }
-            catch (error) {
-                this.$logger.trace("Error while trying to get component information. Error is: ", error);
-                return [];
-            }
-        });
-    }
-    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;
                 }
+                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 [];
+        }
+    }
+    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;
+            }
         });
     }
     getProjectData() {