@akylas/nativescript-cli 8.7.2

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

@@ -0,0 +1,154 @@
+"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");
+const path = require("path");
+const os = require("os");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+const package_path_helper_1 = require("../helpers/package-path-helper");
+class TestExecutionService {
+    constructor($runController, $httpClient, $config, $logger, $fs, $options, $pluginsService, $projectDataService, $childProcess) {
+        this.$runController = $runController;
+        this.$httpClient = $httpClient;
+        this.$config = $config;
+        this.$logger = $logger;
+        this.$fs = $fs;
+        this.$options = $options;
+        this.$pluginsService = $pluginsService;
+        this.$projectDataService = $projectDataService;
+        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);
+                });
+            });
+            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 });
+            });
+        });
+    }
+    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;
+                }
+            });
+            const pathToKarma = (0, package_path_helper_1.resolvePackagePath)("karma", {
+                paths: [projectData.projectDir],
+            });
+            canStartKarmaServer = canStartKarmaServer && !!pathToKarma;
+            return canStartKarmaServer;
+        });
+    }
+    generateConfig(port, options) {
+        const nics = os.networkInterfaces();
+        const ips = Object.keys(nics)
+            .map((nicName) => nics[nicName].filter((binding) => binding.family === "IPv4" || binding.family === 4)[0])
+            .filter((binding) => !!binding)
+            .map((binding) => binding.address);
+        const config = {
+            port,
+            ips,
+            options,
+        };
+        return "module.exports = " + JSON.stringify(config);
+    }
+    getKarmaConfiguration(platform, projectData) {
+        const karmaConfig = {
+            browsers: [platform],
+            configFile: path.join(projectData.projectDir, "karma.conf.js"),
+            _NS: {
+                log: this.$logger.getLevel(),
+                path: this.$options.path,
+                tns: process.argv[1],
+                node: process.execPath,
+                env: this.$options.env,
+                options: {
+                    debugTransport: this.$options.debugTransport,
+                    debugBrk: this.$options.debugBrk,
+                    watch: !!this.$options.watch,
+                    bundle: true,
+                    appDirectoryRelativePath: projectData.getAppDirectoryRelativePath(),
+                },
+            },
+        };
+        if (this.$config.DEBUG || this.$logger.getLevel() === "TRACE") {
+            karmaConfig.logLevel = "DEBUG";
+        }
+        if (!this.$options.watch) {
+            karmaConfig.singleRun = true;
+        }
+        if (this.$options.debugBrk) {
+            karmaConfig.browserNoActivityTimeout = 1000000000;
+        }
+        karmaConfig.projectDir = projectData.projectDir;
+        karmaConfig.bundle = true;
+        karmaConfig.debugBrk = this.$options.debugBrk;
+        karmaConfig.appPath = projectData.getAppDirectoryRelativePath();
+        karmaConfig.platform = platform.toLowerCase();
+        this.$logger.trace(JSON.stringify(karmaConfig, null, 4));
+        return karmaConfig;
+    }
+}
+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

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestInitializationService = void 0;
+const path = require("path");
+const fs = require("fs");
+const decorators_1 = require("../common/decorators");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+class TestInitializationService {
+    constructor($errors, $fs) {
+        this.$errors = $errors;
+        this.$fs = $fs;
+        this.configsPath = path.join(__dirname, "..", "..", "config");
+    }
+    getDependencies(selectedFramework) {
+        const dependenciesPath = path.join(this.configsPath, "test-dependencies.json");
+        const allDependencies = this.$fs.readJson(dependenciesPath);
+        const dependenciesVersionsPath = path.join(this.configsPath, "test-deps-versions-generated.json");
+        const dependenciesVersions = this.$fs.readJson(dependenciesVersionsPath);
+        const targetFrameworkDependencies = allDependencies
+            .filter((dependency) => !dependency.framework || dependency.framework === selectedFramework)
+            .map((dependency) => {
+            const dependencyVersion = dependenciesVersions[dependency.name];
+            if (!dependencyVersion) {
+                this.$errors.fail(`'${dependency}' is not a registered dependency.`);
+            }
+            return Object.assign(Object.assign({}, dependency), { version: dependencyVersion });
+        });
+        return targetFrameworkDependencies;
+    }
+    getFrameworkNames() {
+        const configsPath = path.join(__dirname, "..", "..", "config");
+        const dependenciesPath = path.join(configsPath, "test-dependencies.json");
+        const allDependencies = JSON.parse(fs.readFileSync(dependenciesPath, { encoding: "utf-8" }));
+        const frameworks = _.uniqBy(allDependencies, "framework")
+            .map((item) => item && item.framework)
+            .filter((item) => item);
+        return frameworks;
+    }
+}
+__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

@@ -0,0 +1,108 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelineProfilerService = void 0;
+const decorators_1 = require("../common/decorators");
+const yok_1 = require("../common/yok");
+const path = require("path");
+const nativescript_cli_1 = require("../nativescript-cli");
+const color_1 = require("../color");
+const TIMELINE_LOG_RE = /Timeline:\s*(\d*.?\d*ms:\s*)?([^\:]*\:)?(.*)\((\d*.?\d*)ms\.?\s*-\s*(\d*.\d*)ms\.?\)/;
+var ChromeTraceEventPhase;
+(function (ChromeTraceEventPhase) {
+    ChromeTraceEventPhase["BEGIN"] = "B";
+    ChromeTraceEventPhase["END"] = "E";
+    ChromeTraceEventPhase["INSTANT"] = "i";
+    ChromeTraceEventPhase["COMPLETE"] = "X";
+})(ChromeTraceEventPhase || (ChromeTraceEventPhase = {}));
+class TimelineProfilerService {
+    constructor($projectConfigService, $fs, $logger) {
+        this.$projectConfigService = $projectConfigService;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.timelines = new Map();
+        this.attachedExitHandler = false;
+    }
+    attachExitHanlder() {
+        if (!this.attachedExitHandler) {
+            this.$logger.info('attached "SIGINT" handler to write timeline data.');
+            (0, nativescript_cli_1.originalProcessOn)("SIGINT", this.writeTimelines.bind(this));
+            this.attachedExitHandler = true;
+        }
+    }
+    processLogData(data, deviceIdentifier) {
+        if (!this.isEnabled()) {
+            return;
+        }
+        this.attachExitHanlder();
+        if (!this.timelines.has(deviceIdentifier)) {
+            this.timelines.set(deviceIdentifier, {
+                startPoint: null,
+                timeline: [],
+            });
+        }
+        const deviceTimeline = this.timelines.get(deviceIdentifier);
+        data.split("\n").forEach((line) => {
+            var _a;
+            const trace = this.toTrace(line.trim());
+            if (trace) {
+                (_a = deviceTimeline.startPoint) !== null && _a !== void 0 ? _a : (deviceTimeline.startPoint = trace[0].ts);
+                deviceTimeline.timeline.push(...trace);
+            }
+        });
+    }
+    isEnabled() {
+        return this.$projectConfigService.getValue("profiling") === "timeline";
+    }
+    toTrace(text) {
+        var _a, _b, _c;
+        const result = text.match(TIMELINE_LOG_RE);
+        if (!result) {
+            return;
+        }
+        const trace = {
+            domain: (_a = result[2]) === null || _a === void 0 ? void 0 : _a.trim().replace(":", ".").toLowerCase(),
+            name: result[3].trim(),
+            from: parseFloat(result[4]),
+            to: parseFloat(result[5]),
+        };
+        return [{
+                args: {},
+                pid: 1,
+                tid: 1,
+                ts: trace.from * 1000,
+                name: trace.name,
+                cat: (_b = trace.domain) !== null && _b !== void 0 ? _b : "default",
+                ph: ChromeTraceEventPhase.BEGIN,
+            }, {
+                args: {},
+                pid: 1,
+                tid: 1,
+                ts: trace.to * 1000,
+                name: trace.name,
+                cat: (_c = trace.domain) !== null && _c !== void 0 ? _c : "default",
+                ph: ChromeTraceEventPhase.END,
+            }];
+    }
+    writeTimelines() {
+        this.$logger.info("\n\nWriting timeline data to json...");
+        this.timelines.forEach((deviceTimeline, deviceIdentifier) => {
+            const deviceTimelineFileName = `timeline-${deviceIdentifier}.json`;
+            this.$fs.writeJson(path.resolve(process.cwd(), deviceTimelineFileName), deviceTimeline.timeline);
+            this.$logger.info(`Timeline data for device ${color_1.color.cyan(deviceIdentifier)} written to ${color_1.color.green(deviceTimelineFileName)}`);
+        });
+        this.$logger.info(color_1.color.green("\n\nTo view the timeline data, open the following URL in Chrome, and load the json file:"));
+        this.$logger.info(color_1.color.green("devtools://devtools/bundled/inspector.html?panel=timeline\n\n"));
+        process.exit();
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], TimelineProfilerService.prototype, "isEnabled", null);
+exports.TimelineProfilerService = TimelineProfilerService;
+yok_1.injector.register("timelineProfilerService", TimelineProfilerService);

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSettingsService = void 0;
+const path = require("path");
+const yok_1 = require("../common/yok");
+class UserSettingsService {
+    get $jsonFileSettingsService() {
+        const userSettingsFilePath = path.join(this.$settingsService.getProfileDir(), "user-settings.json");
+        return this.$injector.resolve("jsonFileSettingsService", {
+            jsonFileSettingsPath: userSettingsFilePath,
+        });
+    }
+    constructor($injector, $settingsService) {
+        this.$injector = $injector;
+        this.$settingsService = $settingsService;
+    }
+    getSettingValue(settingName, cacheOpts) {
+        return this.$jsonFileSettingsService.getSettingValue(settingName, cacheOpts);
+    }
+    saveSetting(key, value, cacheOpts) {
+        return this.$jsonFileSettingsService.saveSetting(key, value, cacheOpts);
+    }
+    saveSettings(data, cacheOpts) {
+        return this.$jsonFileSettingsService.saveSettings(data, cacheOpts);
+    }
+    removeSetting(key) {
+        return this.$jsonFileSettingsService.removeSetting(key);
+    }
+    loadUserSettingsFile() {
+        return this.$jsonFileSettingsService.loadUserSettingsFile();
+    }
+}
+exports.UserSettingsService = UserSettingsService;
+yok_1.injector.register("userSettingsService", UserSettingsService);

package/lib/services/versions-service.js

@@ -0,0 +1,196 @@
+"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");
+const helpers = require("../common/helpers");
+const semver = require("semver");
+const path = require("path");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+var VersionInformationType;
+(function (VersionInformationType) {
+    VersionInformationType["UpToDate"] = "UpToDate";
+    VersionInformationType["UpdateAvailable"] = "UpdateAvailable";
+    VersionInformationType["NotInstalled"] = "NotInstalled";
+})(VersionInformationType = exports.VersionInformationType || (exports.VersionInformationType = {}));
+class VersionsService {
+    constructor($fs, $packageInstallationManager, $injector, $logger, $staticConfig, $pluginsService, $projectDataService, $terminalSpinnerService) {
+        this.$fs = $fs;
+        this.$packageInstallationManager = $packageInstallationManager;
+        this.$injector = $injector;
+        this.$logger = $logger;
+        this.$staticConfig = $staticConfig;
+        this.$pluginsService = $pluginsService;
+        this.$projectDataService = $projectDataService;
+        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,
+            };
+        });
+    }
+    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);
+                }
+            }
+            else {
+                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,
+                };
+                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.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 [];
+            }
+        });
+    }
+    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() {
+        try {
+            const projectData = this.$injector.resolve("projectData");
+            projectData.initializeProjectData();
+            return projectData;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    hasUpdate(component) {
+        return !semver.satisfies(component.latestVersion, semver.validRange(component.currentVersion));
+    }
+}
+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);

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchIgnoreListService = void 0;
+const yok_1 = require("../common/yok");
+class WatchIgnoreListService {
+    constructor() {
+        this.ignoreMap = {};
+    }
+    addFileToIgnoreList(filePath) {
+        this.ignoreMap[filePath] = true;
+    }
+    removeFileFromIgnoreList(filePath) {
+        this.ignoreMap[filePath] = false;
+    }
+    isFileInIgnoreList(filePath) {
+        return !!this.ignoreMap[filePath];
+    }
+}
+exports.WatchIgnoreListService = WatchIgnoreListService;
+yok_1.injector.register("watchIgnoreListService", WatchIgnoreListService);