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

package/lib/services/platform-environment-requirements.js

@@ -5,48 +5,62 @@ 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.PlatformEnvironmentRequirements = void 0;
 const helpers_1 = require("../common/helpers");
 const os_1 = require("os");
 const yok_1 = require("../common/yok");
 class PlatformEnvironmentRequirements {
-    constructor($doctorService, $errors, $analyticsService, $injector) {
+    constructor($doctorService, $errors, $analyticsService, 
+    // @ts-ignore - required by the hook helper!
+    $injector) {
         this.$doctorService = $doctorService;
         this.$errors = $errors;
         this.$analyticsService = $analyticsService;
         this.$injector = $injector;
     }
-    async checkEnvironmentRequirements(input) {
-        const { platform, projectDir, runtimeVersion } = input;
-        const selectedOption = null;
-        if (process.env.NS_SKIP_ENV_CHECK) {
-            await this.$analyticsService.trackEventActionInGoogleAnalytics({
-                action: "Check Environment Requirements",
-                additionalData: "Skipped: NS_SKIP_ENV_CHECK is set",
+    checkEnvironmentRequirements(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { platform, projectDir, runtimeVersion } = input;
+            const selectedOption = null;
+            if (process.env.NS_SKIP_ENV_CHECK) {
+                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                    action: "Check Environment Requirements" /* TrackActionNames.CheckEnvironmentRequirements */,
+                    additionalData: "Skipped: NS_SKIP_ENV_CHECK is set",
+                });
+                return {
+                    canExecute: true,
+                    selectedOption,
+                };
+            }
+            const canExecute = yield this.$doctorService.canExecuteLocalBuild({
+                platform,
+                projectDir,
+                runtimeVersion,
+                forceCheck: input.forceCheck,
             });
+            if (!canExecute) {
+                // if (!isInteractive()) {
+                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                    action: "Check Environment Requirements" /* TrackActionNames.CheckEnvironmentRequirements */,
+                    additionalData: "Non-interactive terminal, unable to execute local builds.",
+                });
+                this.fail(this.getNonInteractiveConsoleMessage(platform));
+            }
             return {
-                canExecute: true,
+                canExecute,
                 selectedOption,
             };
-        }
-        const canExecute = await this.$doctorService.canExecuteLocalBuild({
-            platform,
-            projectDir,
-            runtimeVersion,
-            forceCheck: input.forceCheck,
         });
-        if (!canExecute) {
-            await this.$analyticsService.trackEventActionInGoogleAnalytics({
-                action: "Check Environment Requirements",
-                additionalData: "Non-interactive terminal, unable to execute local builds.",
-            });
-            this.fail(this.getNonInteractiveConsoleMessage(platform));
-        }
-        return {
-            canExecute,
-            selectedOption,
-        };
     }
     fail(message) {
         this.$errors.fail({ formatStr: message, printOnStdout: true });
@@ -58,6 +72,7 @@ class PlatformEnvironmentRequirements {
         ].join(os_1.EOL);
     }
     getEnvVerificationMessage(platform) {
+        // map process.platform to OS name used in docs
         const os = {
             linux: "linux",
             win32: "windows",
@@ -70,9 +85,10 @@ class PlatformEnvironmentRequirements {
             `https://docs.nativescript.org/setup/${os}${anchor}.`);
     }
 }
-exports.PlatformEnvironmentRequirements = PlatformEnvironmentRequirements;
 PlatformEnvironmentRequirements.MISSING_LOCAL_SETUP_MESSAGE = "Your environment is not configured properly and you will not be able to execute local builds.";
 __decorate([
     (0, helpers_1.hook)("checkEnvironment")
 ], PlatformEnvironmentRequirements.prototype, "checkEnvironmentRequirements", null);
+exports.PlatformEnvironmentRequirements = PlatformEnvironmentRequirements;
 yok_1.injector.register("platformEnvironmentRequirements", PlatformEnvironmentRequirements);
+//# sourceMappingURL=platform-environment-requirements.js.map

package/lib/services/platform-project-service-base.js

@@ -30,3 +30,4 @@ class PlatformProjectServiceBase extends events_1.EventEmitter {
     }
 }
 exports.PlatformProjectServiceBase = PlatformProjectServiceBase;
+//# sourceMappingURL=platform-project-service-base.js.map

package/lib/services/platforms-data-service.js

@@ -29,3 +29,4 @@ class PlatformsDataService {
 }
 exports.PlatformsDataService = PlatformsDataService;
 yok_1.injector.register("platformsDataService", PlatformsDataService);
+//# sourceMappingURL=platforms-data-service.js.map

package/lib/services/plugins-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.PluginsService = void 0;
 const path = require("path");
@@ -42,46 +51,51 @@ class PluginsService {
             return key;
         });
     }
-    async add(plugin, projectData) {
-        await this.ensure(projectData);
-        const possiblePackageName = path.resolve(plugin);
-        if (possiblePackageName.indexOf(".tgz") !== -1 &&
-            this.$fs.exists(possiblePackageName)) {
-            plugin = possiblePackageName;
-        }
-        const name = (await this.$packageManager.install(plugin, projectData.projectDir, this.npmInstallOptions)).name;
-        const pathToRealNpmPackageJson = this.getPackageJsonFilePathForModule(name, projectData.projectDir);
-        const realNpmPackageJson = this.$fs.readJson(pathToRealNpmPackageJson);
-        if (realNpmPackageJson.nativescript) {
-            const pluginData = this.convertToPluginData(realNpmPackageJson, projectData.projectDir);
-            const action = async (pluginDestinationPath, platform, platformData) => {
-                this.isPluginDataValidForPlatform(pluginData, platform, projectData);
-            };
-            await this.executeForAllInstalledPlatforms(action, projectData);
-            this.$logger.info(`Successfully installed plugin ${realNpmPackageJson.name}.`);
-        }
-        else {
-            await this.$packageManager.uninstall(realNpmPackageJson.name, { save: true }, projectData.projectDir);
-            this.$errors.fail(`${plugin} is not a valid NativeScript plugin. Verify that the plugin package.json file contains a nativescript key and try again.`);
-        }
+    add(plugin, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensure(projectData);
+            const possiblePackageName = path.resolve(plugin);
+            if (possiblePackageName.indexOf(".tgz") !== -1 &&
+                this.$fs.exists(possiblePackageName)) {
+                plugin = possiblePackageName;
+            }
+            const name = (yield this.$packageManager.install(plugin, projectData.projectDir, this.npmInstallOptions)).name;
+            const pathToRealNpmPackageJson = this.getPackageJsonFilePathForModule(name, projectData.projectDir);
+            const realNpmPackageJson = this.$fs.readJson(pathToRealNpmPackageJson);
+            if (realNpmPackageJson.nativescript) {
+                const pluginData = this.convertToPluginData(realNpmPackageJson, projectData.projectDir);
+                // Validate
+                const action = (pluginDestinationPath, platform, platformData) => __awaiter(this, void 0, void 0, function* () {
+                    this.isPluginDataValidForPlatform(pluginData, platform, projectData);
+                });
+                yield this.executeForAllInstalledPlatforms(action, projectData);
+                this.$logger.info(`Successfully installed plugin ${realNpmPackageJson.name}.`);
+            }
+            else {
+                yield this.$packageManager.uninstall(realNpmPackageJson.name, { save: true }, projectData.projectDir);
+                this.$errors.fail(`${plugin} is not a valid NativeScript plugin. Verify that the plugin package.json file contains a nativescript key and try again.`);
+            }
+        });
     }
-    async remove(pluginName, projectData) {
-        const removePluginNativeCodeAction = async (modulesDestinationPath, platform, platformData) => {
-            const pluginData = this.convertToPluginData(this.getNodeModuleData(pluginName, projectData.projectDir), projectData.projectDir);
-            await platformData.platformProjectService.removePluginNativeCode(pluginData, projectData);
-        };
-        await this.executeForAllInstalledPlatforms(removePluginNativeCodeAction, projectData);
-        await this.executeNpmCommand(PluginsService.UNINSTALL_COMMAND_NAME, pluginName, projectData);
-        let showMessage = true;
-        const action = async (modulesDestinationPath, platform, platformData) => {
-            shelljs.rm("-rf", path.join(modulesDestinationPath, pluginName));
-            this.$logger.info(`Successfully removed plugin ${pluginName} for ${platform}.`);
-            showMessage = false;
-        };
-        await this.executeForAllInstalledPlatforms(action, projectData);
-        if (showMessage) {
-            this.$logger.info(`Successfully removed plugin ${pluginName}`);
-        }
+    remove(pluginName, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const removePluginNativeCodeAction = (modulesDestinationPath, platform, platformData) => __awaiter(this, void 0, void 0, function* () {
+                const pluginData = this.convertToPluginData(this.getNodeModuleData(pluginName, projectData.projectDir), projectData.projectDir);
+                yield platformData.platformProjectService.removePluginNativeCode(pluginData, projectData);
+            });
+            yield this.executeForAllInstalledPlatforms(removePluginNativeCodeAction, projectData);
+            yield this.executeNpmCommand(PluginsService.UNINSTALL_COMMAND_NAME, pluginName, projectData);
+            let showMessage = true;
+            const action = (modulesDestinationPath, platform, platformData) => __awaiter(this, void 0, void 0, function* () {
+                shelljs.rm("-rf", path.join(modulesDestinationPath, pluginName));
+                this.$logger.info(`Successfully removed plugin ${pluginName} for ${platform}.`);
+                showMessage = false;
+            });
+            yield this.executeForAllInstalledPlatforms(action, projectData);
+            if (showMessage) {
+                this.$logger.info(`Successfully removed plugin ${pluginName}`);
+            }
+        });
     }
     addToPackageJson(plugin, version, isDev, projectDir) {
         const packageJsonPath = this.getPackageJsonFilePath(projectDir);
@@ -105,56 +119,65 @@ class PluginsService {
             this.$fs.writeJson(packageJsonPath, result.packageJsonContent);
         }
     }
-    async preparePluginNativeCode({ pluginData, platform, projectData, }) {
-        const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
-        const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(platform);
-        if (this.$fs.exists(pluginPlatformsFolderPath)) {
-            const pathToPluginsBuildFile = path.join(platformData.projectRoot, constants.PLUGINS_BUILD_DATA_FILENAME);
-            const allPluginsNativeHashes = this.getAllPluginsNativeHashes(pathToPluginsBuildFile);
-            const oldPluginNativeHashes = allPluginsNativeHashes[pluginData.name];
-            const currentPluginNativeHashes = await this.getPluginNativeHashes(pluginPlatformsFolderPath);
-            if (!oldPluginNativeHashes ||
-                this.$filesHashService.hasChangesInShasums(oldPluginNativeHashes, currentPluginNativeHashes)) {
-                await platformData.platformProjectService.preparePluginNativeCode(pluginData, projectData);
-                const updatedPluginNativeHashes = await this.getPluginNativeHashes(pluginPlatformsFolderPath);
-                this.setPluginNativeHashes({
-                    pathToPluginsBuildFile,
-                    pluginData,
-                    currentPluginNativeHashes: updatedPluginNativeHashes,
-                    allPluginsNativeHashes,
-                });
+    preparePluginNativeCode({ pluginData, platform, projectData, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+            const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(platform);
+            if (this.$fs.exists(pluginPlatformsFolderPath)) {
+                const pathToPluginsBuildFile = path.join(platformData.projectRoot, constants.PLUGINS_BUILD_DATA_FILENAME);
+                const allPluginsNativeHashes = this.getAllPluginsNativeHashes(pathToPluginsBuildFile);
+                const oldPluginNativeHashes = allPluginsNativeHashes[pluginData.name];
+                const currentPluginNativeHashes = yield this.getPluginNativeHashes(pluginPlatformsFolderPath);
+                if (!oldPluginNativeHashes ||
+                    this.$filesHashService.hasChangesInShasums(oldPluginNativeHashes, currentPluginNativeHashes)) {
+                    yield platformData.platformProjectService.preparePluginNativeCode(pluginData, projectData);
+                    const updatedPluginNativeHashes = yield this.getPluginNativeHashes(pluginPlatformsFolderPath);
+                    this.setPluginNativeHashes({
+                        pathToPluginsBuildFile,
+                        pluginData,
+                        currentPluginNativeHashes: updatedPluginNativeHashes,
+                        allPluginsNativeHashes,
+                    });
+                }
             }
-        }
+        });
     }
-    async ensureAllDependenciesAreInstalled(projectData) {
-        const packageJsonContent = this.$fs.readJson(this.getPackageJsonFilePath(projectData.projectDir));
-        const allDependencies = _.keys(packageJsonContent.dependencies).concat(_.keys(packageJsonContent.devDependencies));
-        const notInstalledDependencies = allDependencies
-            .map((dep) => {
-            this.$logger.trace(`Checking if ${dep} is installed...`);
-            const pathToPackage = (0, package_path_helper_1.resolvePackagePath)(dep, {
-                paths: [projectData.projectDir],
-            });
-            if (pathToPackage) {
-                return false;
+    ensureAllDependenciesAreInstalled(projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const packageJsonContent = this.$fs.readJson(this.getPackageJsonFilePath(projectData.projectDir));
+            const allDependencies = _.keys(packageJsonContent.dependencies).concat(_.keys(packageJsonContent.devDependencies));
+            const notInstalledDependencies = allDependencies
+                .map((dep) => {
+                this.$logger.trace(`Checking if ${dep} is installed...`);
+                const pathToPackage = (0, package_path_helper_1.resolvePackagePath)(dep, {
+                    paths: [projectData.projectDir],
+                });
+                if (pathToPackage) {
+                    // return false if the dependency is installed - we'll filter out boolean values
+                    // and end up with an array of dep names that are not installed if we end up
+                    // inside the catch block.
+                    return false;
+                }
+                this.$logger.trace(`${dep} is not installed, or couldn't be found`);
+                return dep;
+            })
+                .filter(Boolean);
+            if (this.$options.force || notInstalledDependencies.length) {
+                this.$logger.trace("Npm install will be called from CLI. Force option is: ", this.$options.force, " Not installed dependencies are: ", notInstalledDependencies);
+                yield this.$packageManager.install(projectData.projectDir, projectData.projectDir, {
+                    disableNpmInstall: this.$options.disableNpmInstall,
+                    frameworkPath: this.$options.frameworkPath,
+                    ignoreScripts: this.$options.ignoreScripts,
+                    path: this.$options.path,
+                });
             }
-            this.$logger.trace(`${dep} is not installed, or couldn't be found`);
-            return dep;
-        })
-            .filter(Boolean);
-        if (this.$options.force || notInstalledDependencies.length) {
-            this.$logger.trace("Npm install will be called from CLI. Force option is: ", this.$options.force, " Not installed dependencies are: ", notInstalledDependencies);
-            await this.$packageManager.install(projectData.projectDir, projectData.projectDir, {
-                disableNpmInstall: this.$options.disableNpmInstall,
-                frameworkPath: this.$options.frameworkPath,
-                ignoreScripts: this.$options.ignoreScripts,
-                path: this.$options.path,
-            });
-        }
+        });
     }
-    async getAllInstalledPlugins(projectData) {
-        const nodeModules = (await this.getAllInstalledModules(projectData)).map((nodeModuleData) => this.convertToPluginData(nodeModuleData, projectData.projectDir));
-        return _.filter(nodeModules, (nodeModuleData) => nodeModuleData && nodeModuleData.isPlugin);
+    getAllInstalledPlugins(projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodeModules = (yield this.getAllInstalledModules(projectData)).map((nodeModuleData) => this.convertToPluginData(nodeModuleData, projectData.projectDir));
+            return _.filter(nodeModules, (nodeModuleData) => nodeModuleData && nodeModuleData.isPlugin);
+        });
     }
     getAllProductionPlugins(projectData, platform, dependencies) {
         dependencies =
@@ -168,6 +191,9 @@ class PluginsService {
         return productionPlugins
             .map((plugin) => this.convertToPluginData(plugin, projectData.projectDir))
             .filter((item, idx, self) => {
+            // Filter out duplicates to speed up build times by not building the same dependency
+            // multiple times. One possible downside is that if there are different versions
+            // of the same native dependency only the first one in the array will be built
             return self.findIndex((p) => p.name === item.name) === idx;
         });
     }
@@ -199,9 +225,11 @@ class PluginsService {
         const dependenciesGroupedByName = _.groupBy(productionDependencies, (p) => p.name);
         _.each(dependenciesGroupedByName, (dependencyOccurrences, dependencyName) => {
             if (dependencyOccurrences.length > 1) {
+                // the dependency exists multiple times in node_modules
                 const dependencyOccurrencesGroupedByVersion = _.groupBy(dependencyOccurrences, (g) => g.version);
                 const versions = _.keys(dependencyOccurrencesGroupedByVersion);
                 if (versions.length === 1) {
+                    // all dependencies with this name have the same version
                     this.$logger.trace(`Detected same versions (${_.first(versions)}) of the ${dependencyName} installed at locations: ${_.map(dependencyOccurrences, (d) => d.directory).join(", ")}`);
                 }
                 else {
@@ -218,11 +246,7 @@ class PluginsService {
                 const contents = this.$fs.readDirectory(pathToPlatforms);
                 _.each(contents, (file) => {
                     if (path.extname(file) === ".framework") {
-                        dependenciesWithFrameworks.push({
-                            ...d,
-                            frameworkName: path.basename(file),
-                            frameworkLocation: path.join(pathToPlatforms, file),
-                        });
+                        dependenciesWithFrameworks.push(Object.assign(Object.assign({}, d), { frameworkName: path.basename(file), frameworkLocation: path.join(pathToPlatforms, file) }));
                     }
                 });
             }
@@ -231,9 +255,11 @@ class PluginsService {
             const dependenciesGroupedByFrameworkName = _.groupBy(dependenciesWithFrameworks, (d) => d.frameworkName);
             _.each(dependenciesGroupedByFrameworkName, (dependencyOccurrences, frameworkName) => {
                 if (dependencyOccurrences.length > 1) {
+                    // A framework exists multiple times in node_modules
                     const groupedByName = _.groupBy(dependencyOccurrences, (d) => d.name);
                     const pluginsNames = _.keys(groupedByName);
                     if (pluginsNames.length > 1) {
+                        // fail - the same framework is installed by different dependencies.
                         const locations = dependencyOccurrences.map((d) => d.frameworkLocation);
                         let msg = `Detected the framework ${frameworkName} is installed from multiple plugins at locations:\n${locations.join("\n")}\n`;
                         msg += this.getHelpMessage(projectDir);
@@ -243,6 +269,7 @@ class PluginsService {
                     const dependencyOccurrencesGroupedByVersion = _.groupBy(dependencyOccurrences, (g) => g.version);
                     const versions = _.keys(dependencyOccurrencesGroupedByVersion);
                     if (versions.length === 1) {
+                        // all dependencies with this name have the same version
                         this.$logger.warn(`Detected the framework ${frameworkName} is installed multiple times from the same versions of plugin (${_.first(versions)}) at locations: ${_.map(dependencyOccurrences, (d) => d.directory).join(", ")}`);
                         const selectedPackage = _.minBy(dependencyOccurrences, (d) => d.depth);
                         this.$logger.info(color_1.color.green(`CLI will use only the native code from '${selectedPackage.directory}'.`));
@@ -294,7 +321,7 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
             pluginData.isPlugin = !!cacheData.nativescript;
             pluginData.pluginPlatformsFolderPath = (platform) => {
                 if (this.$mobileHelper.isvisionOSPlatform(platform)) {
-                    platform = "ios";
+                    platform = "ios" /* constants.PlatformTypes.ios */;
                 }
                 return path.join(pluginData.fullPath, "platforms", platform.toLowerCase());
             };
@@ -351,6 +378,7 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
         return _.keys(require(packageJsonFilePath).dependencies);
     }
     getNodeModuleData(module, projectDir) {
+        // module can be  modulePath or moduleName
         if (!this.$fs.exists(module) || path.basename(module) !== "package.json") {
             module = this.getPackageJsonFilePathForModule(module, projectDir);
         }
@@ -363,40 +391,50 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
             nativescript: data.nativescript,
         };
     }
-    async ensure(projectData) {
-        await this.ensureAllDependenciesAreInstalled(projectData);
-        this.$fs.ensureDirectoryExists(this.getNodeModulesPath(projectData.projectDir));
+    ensure(projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureAllDependenciesAreInstalled(projectData);
+            this.$fs.ensureDirectoryExists(this.getNodeModulesPath(projectData.projectDir));
+        });
     }
-    async getAllInstalledModules(projectData) {
-        await this.ensure(projectData);
-        const nodeModules = this.getDependencies(projectData.projectDir);
-        return _.map(nodeModules, (nodeModuleName) => this.getNodeModuleData(nodeModuleName, projectData.projectDir));
+    getAllInstalledModules(projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensure(projectData);
+            const nodeModules = this.getDependencies(projectData.projectDir);
+            return _.map(nodeModules, (nodeModuleName) => this.getNodeModuleData(nodeModuleName, projectData.projectDir));
+        });
     }
-    async executeNpmCommand(npmCommandName, npmCommandArguments, projectData) {
-        if (npmCommandName === PluginsService.INSTALL_COMMAND_NAME) {
-            await this.$packageManager.install(npmCommandArguments, projectData.projectDir, this.npmInstallOptions);
-        }
-        else if (npmCommandName === PluginsService.UNINSTALL_COMMAND_NAME) {
-            await this.$packageManager.uninstall(npmCommandArguments, PluginsService.NPM_CONFIG, projectData.projectDir);
-        }
-        return this.parseNpmCommandResult(npmCommandArguments);
+    executeNpmCommand(npmCommandName, npmCommandArguments, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (npmCommandName === PluginsService.INSTALL_COMMAND_NAME) {
+                yield this.$packageManager.install(npmCommandArguments, projectData.projectDir, this.npmInstallOptions);
+            }
+            else if (npmCommandName === PluginsService.UNINSTALL_COMMAND_NAME) {
+                yield this.$packageManager.uninstall(npmCommandArguments, PluginsService.NPM_CONFIG, projectData.projectDir);
+            }
+            return this.parseNpmCommandResult(npmCommandArguments);
+        });
     }
     parseNpmCommandResult(npmCommandResult) {
-        return npmCommandResult.split("@")[0];
-    }
-    async executeForAllInstalledPlatforms(action, projectData) {
-        const availablePlatforms = this.$mobileHelper.platformNames.map((p) => p.toLowerCase());
-        for (const platform of availablePlatforms) {
-            const isPlatformInstalled = this.$fs.exists(path.join(projectData.platformsDir, platform.toLowerCase()));
-            if (isPlatformInstalled) {
-                const platformData = this.$platformsDataService.getPlatformData(platform.toLowerCase(), projectData);
-                const pluginDestinationPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, "tns_modules");
-                await action(pluginDestinationPath, platform.toLowerCase(), platformData);
+        return npmCommandResult.split("@")[0]; // returns plugin name
+    }
+    executeForAllInstalledPlatforms(action, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availablePlatforms = this.$mobileHelper.platformNames.map((p) => p.toLowerCase());
+            for (const platform of availablePlatforms) {
+                const isPlatformInstalled = this.$fs.exists(path.join(projectData.platformsDir, platform.toLowerCase()));
+                if (isPlatformInstalled) {
+                    const platformData = this.$platformsDataService.getPlatformData(platform.toLowerCase(), projectData);
+                    const pluginDestinationPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, "tns_modules");
+                    yield action(pluginDestinationPath, platform.toLowerCase(), platformData);
+                }
             }
-        }
+        });
     }
     getInstalledFrameworkVersion(platform, projectData) {
         const runtimePackage = this.$projectDataService.getRuntimePackage(projectData.projectDir, platform);
+        // const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+        // const frameworkData = this.$projectDataService.getNSValue(projectData.projectDir, platformData.frameworkPackageName);
         return runtimePackage.version;
     }
     isPluginDataValidForPlatform(pluginData, platform, projectData) {
@@ -416,16 +454,19 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
         }
         return isValid;
     }
-    async getPluginNativeHashes(pluginPlatformsDir) {
-        let data = {};
-        if (this.$fs.exists(pluginPlatformsDir)) {
-            const pluginNativeDataFiles = this.$fs.enumerateFilesInDirectorySync(pluginPlatformsDir);
-            data = await this.$filesHashService.generateHashes(pluginNativeDataFiles);
-        }
-        return data;
+    getPluginNativeHashes(pluginPlatformsDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let data = {};
+            if (this.$fs.exists(pluginPlatformsDir)) {
+                const pluginNativeDataFiles = this.$fs.enumerateFilesInDirectorySync(pluginPlatformsDir);
+                data = yield this.$filesHashService.generateHashes(pluginNativeDataFiles);
+            }
+            return data;
+        });
     }
     getAllPluginsNativeHashes(pathToPluginsBuildFile) {
         if (this.$options.hostProjectPath) {
+            // TODO: force rebuild plugins for now until we decide where to put .ns-plugins-build-data.json when embedding
             return {};
         }
         let data = {};
@@ -436,6 +477,7 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
     }
     setPluginNativeHashes(opts) {
         if (this.$options.hostProjectPath) {
+            // TODO: force rebuild plugins for now until we decide where to put .ns-plugins-build-data.json when embedding
             return;
         }
         opts.allPluginsNativeHashes[opts.pluginData.name] =
@@ -443,7 +485,6 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
         this.$fs.writeJson(opts.pathToPluginsBuildFile, opts.allPluginsNativeHashes);
     }
 }
-exports.PluginsService = PluginsService;
 PluginsService.INSTALL_COMMAND_NAME = "install";
 PluginsService.UNINSTALL_COMMAND_NAME = "uninstall";
 PluginsService.NPM_CONFIG = {
@@ -455,4 +496,6 @@ PluginsService.LOCK_FILES = [
     "yarn.lock",
     "pnpm-lock.yaml",
 ];
+exports.PluginsService = PluginsService;
 yok_1.injector.register("pluginsService", PluginsService);
+//# sourceMappingURL=plugins-service.js.map

package/lib/services/prepare-data-service.js

@@ -19,3 +19,4 @@ class PrepareDataService {
 }
 exports.PrepareDataService = PrepareDataService;
 yok_1.injector.register("prepareDataService", PrepareDataService);
+//# sourceMappingURL=prepare-data-service.js.map

package/lib/services/project-backup-service.js

@@ -22,7 +22,6 @@ class ProjectBackupService {
         return backup.restore();
     }
 }
-exports.ProjectBackupService = ProjectBackupService;
 ProjectBackupService.Backup = class Backup {
     constructor($super, name, pathsToBackup = [], basePath = $super.$projectHelper.projectDir) {
         this.$super = $super;
@@ -47,6 +46,7 @@ ProjectBackupService.Backup = class Backup {
                 backedUpPaths.push(pathToBackup);
             }
         }
+        // create backup.json
         this.$super.$fs.writeJson(path.resolve(this.backupDir, "_backup.json"), {
             name: this.name,
             paths: backedUpPaths,
@@ -67,6 +67,7 @@ ProjectBackupService.Backup = class Backup {
             }
         }
         this.$super.$logger.trace(backupData);
+        // restore files
         return this;
     }
     isUpToDate() {
@@ -76,6 +77,7 @@ ProjectBackupService.Backup = class Backup {
         }
         for (const pathToBackup of backupData.paths) {
             const sourcePath = path.resolve(this.backupDir, pathToBackup);
+            // if any of the files don't exist the backup is not up-to-date
             if (!this.$super.$fs.exists(sourcePath)) {
                 return false;
             }
@@ -111,4 +113,6 @@ ProjectBackupService.Backup = class Backup {
         return this.$super.$fs.readJson(backupJSONPath);
     }
 };
+exports.ProjectBackupService = ProjectBackupService;
 yok_1.injector.register("projectBackupService", ProjectBackupService);
+//# sourceMappingURL=project-backup-service.js.map