nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

package/lib/services/platform/add-platform-service.d.ts

@@ -0,0 +1,21 @@
+import { IAddPlatformData, IAddPlatformService, IPlatformData } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+import { IAnalyticsService, IFileSystem } from "../../common/declarations";
+import { IOptions, IPackageManager } from "../../declarations";
+import { ITerminalSpinnerService } from "../../definitions/terminal-spinner-service";
+export declare class AddPlatformService implements IAddPlatformService {
+    private $fs;
+    private $logger;
+    private $options;
+    private $packageManager;
+    private $terminalSpinnerService;
+    private $analyticsService;
+    constructor($fs: IFileSystem, $logger: ILogger, $options: IOptions, $packageManager: IPackageManager, $terminalSpinnerService: ITerminalSpinnerService, $analyticsService: IAnalyticsService);
+    addProjectHost(): Promise<void>;
+    addPlatformSafe(projectData: IProjectData, platformData: IPlatformData, packageToInstall: string, addPlatformData: IAddPlatformData): Promise<string>;
+    setPlatformVersion(platformData: IPlatformData, projectData: IProjectData, frameworkVersion: string): Promise<void>;
+    private installPackage;
+    private resolveFrameworkDir;
+    private addNativePlatform;
+    private trackPlatformVersion;
+}

package/lib/services/platform/add-platform-service.js

@@ -12,11 +12,7 @@ const constants_1 = require("../../constants");
 const decorators_1 = require("../../common/decorators");
 const yok_1 = require("../../common/yok");
 class AddPlatformService {
-    constructor($fs, $logger, $options, 
-    // private $pacoteService: IPacoteService,
-    // private $projectDataService: IProjectDataService,
-    $packageManager, $terminalSpinnerService, $analyticsService // private $tempService: ITempService
-    ) {
+    constructor($fs, $logger, $options, $packageManager, $terminalSpinnerService, $analyticsService) {
         this.$fs = $fs;
         this.$logger = $logger;
         this.$options = $options;
@@ -29,13 +25,9 @@ class AddPlatformService {
         const spinner = this.$terminalSpinnerService.createSpinner();
         try {
             spinner.start();
-            // const frameworkDirPath = addPlatformData.frameworkPath ?
-            // 	await this.extractPackage(packageToInstall)
-            // 	: await this.installPackage(projectData.projectDir, packageToInstall);
             const frameworkDirPath = await this.installPackage(projectData.projectDir, packageToInstall);
             const frameworkPackageJsonContent = this.$fs.readJson(path.join(frameworkDirPath, "..", "package.json"));
             const frameworkVersion = frameworkPackageJsonContent.version;
-            // await this.setPlatformVersion(platformData, projectData, frameworkVersion);
             await this.trackPlatformVersion(frameworkVersion, platformData);
             if (!addPlatformData.nativePrepare ||
                 !addPlatformData.nativePrepare.skipNativePrepare) {
@@ -55,21 +47,9 @@ class AddPlatformService {
     async setPlatformVersion(platformData, projectData, frameworkVersion) {
         await this.installPackage(projectData.projectDir, `${platformData.frameworkPackageName}@${frameworkVersion}`);
     }
-    // private async extractPackage(pkg: string): Promise<string> {
-    // 	const downloadedPackagePath = await this.$tempService.mkdirSync(
-    // 		"runtimeDir"
-    // 	);
-    // 	await this.$pacoteService.extractPackage(pkg, downloadedPackagePath);
-    // 	const frameworkDir = path.join(
-    // 		downloadedPackagePath,
-    // 		PROJECT_FRAMEWORK_FOLDER_NAME
-    // 	);
-    // 	return path.resolve(frameworkDir);
-    // }
     async installPackage(projectDir, packageName) {
         const frameworkDir = this.resolveFrameworkDir(projectDir, packageName);
         if (frameworkDir && this.$fs.exists(frameworkDir)) {
-            // don't install if it's already installed
             return frameworkDir;
         }
         const installedPackage = await this.$packageManager.install(packageName, projectDir, {
@@ -85,30 +65,6 @@ class AddPlatformService {
     }
     resolveFrameworkDir(projectDir, packageName) {
         try {
-            // strip version info if present <package>@1.2.3-rc.0 -> <package>
-            // tested cases:
-            // @nativescript/ios
-            // @nativescript/ios@1
-            // @nativescript/ios@1.2
-            // @nativescript/ios@1.2.3
-            // @nativescript/ios@1.2.3-
-            // @nativescript/ios@1.2.3-rc
-            // @nativescript/ios@1.2.3-rc.
-            // @nativescript/ios@1.2.3-rc.0
-            // @nativescript/ios@rc
-            // @nativescript/ios@^7.0.0
-            // @nativescript/ios@~7.0.0
-            // tns-ios
-            // tns-ios@1
-            // tns-ios@1.2
-            // tns-ios@1.2.3
-            // tns-ios@1.2.3-
-            // tns-ios@1.2.3-rc
-            // tns-ios@1.2.3-rc.
-            // tns-ios@1.2.3-rc.0
-            // tns-ios@rc
-            // tns-ios@^7.0.0
-            // tns-ios@~7.0.0
             packageName = packageName.replace(/(.+)@.+$/g, "$1");
             const frameworkDir = require
                 .resolve(`${packageName}/package.json`, {
@@ -126,10 +82,8 @@ class AddPlatformService {
     }
     async addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion) {
         var _a;
-        // here we should use ios OR android
         const platformDir = (_a = this.$options.hostProjectPath) !== null && _a !== void 0 ? _a : path.join(projectData.platformsDir, platformData.normalizedPlatformName.toLowerCase());
         this.$fs.deleteDirectory(platformDir);
-        //if iosHost - dont create project
         await platformData.platformProjectService.createProject(path.resolve(frameworkDirPath), frameworkVersion, projectData);
         platformData.platformProjectService.ensureConfigurationFileInAppResources(projectData);
         await platformData.platformProjectService.interpolateData(projectData);
@@ -137,7 +91,7 @@ class AddPlatformService {
     }
     async trackPlatformVersion(frameworkVersion, platformData) {
         await this.$analyticsService.trackEventActionInGoogleAnalytics({
-            action: "Add Platform" /* TrackActionNames.AddPlatform */,
+            action: constants_1.TrackActionNames.AddPlatform,
             additionalData: `${platformData.platformNameLowerCase}${constants_1.AnalyticsEventLabelDelimiter}${frameworkVersion}`,
         });
     }
@@ -147,4 +101,3 @@ __decorate([
     (0, decorators_1.performanceLog)()
 ], AddPlatformService.prototype, "addNativePlatform", null);
 yok_1.injector.register("addPlatformService", AddPlatformService);
-//# sourceMappingURL=add-platform-service.js.map

package/lib/services/platform/platform-validation-service.d.ts

@@ -0,0 +1,17 @@
+import { IPlatformValidationService } from "../../declarations";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+import { IErrors, IFileSystem } from "../../common/declarations";
+export declare class PlatformValidationService implements IPlatformValidationService {
+    private $errors;
+    private $fs;
+    private $logger;
+    private $mobileHelper;
+    private $platformsDataService;
+    constructor($errors: IErrors, $fs: IFileSystem, $logger: ILogger, $mobileHelper: Mobile.IMobileHelper, $platformsDataService: IPlatformsDataService);
+    isValidPlatform(platform: string, projectData: IProjectData): boolean;
+    validatePlatform(platform: string, projectData: IProjectData): void;
+    validatePlatformInstalled(platform: string, projectData: IProjectData): void;
+    validateOptions(provision: true | string, teamId: true | string, projectData: IProjectData, platform?: string, aab?: boolean): Promise<boolean>;
+    isPlatformSupportedForOS(platform: string, projectData: IProjectData): boolean;
+}

package/lib/services/platform/platform-validation-service.js

@@ -72,4 +72,3 @@ class PlatformValidationService {
 }
 exports.PlatformValidationService = PlatformValidationService;
 yok_1.injector.register("platformValidationService", PlatformValidationService);
-//# sourceMappingURL=platform-validation-service.js.map

package/lib/services/platform/prepare-native-platform-service.d.ts

@@ -0,0 +1,15 @@
+import { INodeModulesBuilder, IPlatformData } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+import { IMetadataFilteringService } from "../../definitions/metadata-filtering-service";
+import { IHooksService } from "../../common/declarations";
+import { IOptions } from "../../declarations";
+export declare class PrepareNativePlatformService implements IPrepareNativePlatformService {
+    $hooksService: IHooksService;
+    private $nodeModulesBuilder;
+    private $projectChangesService;
+    private $metadataFilteringService;
+    private $options;
+    constructor($hooksService: IHooksService, $nodeModulesBuilder: INodeModulesBuilder, $projectChangesService: IProjectChangesService, $metadataFilteringService: IMetadataFilteringService, $options: IOptions);
+    prepareNativePlatform(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<boolean>;
+    private cleanProject;
+}

package/lib/services/platform/prepare-native-platform-service.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrepareNativePlatformService = void 0;
 const helpers_1 = require("../../common/helpers");
 const decorators_1 = require("../../common/decorators");
+const constants_1 = require("../../constants");
 const yok_1 = require("../../common/yok");
 class PrepareNativePlatformService {
     constructor($hooksService, $nodeModulesBuilder, $projectChangesService, $metadataFilteringService, $options) {
@@ -49,19 +50,17 @@ class PrepareNativePlatformService {
             this.$metadataFilteringService.generateMetadataFilters(projectData, platformData.platformNameLowerCase);
         }
         platformData.platformProjectService.interpolateConfigurationFile(projectData);
-        await this.$projectChangesService.setNativePlatformStatus(platformData, projectData, { nativePlatformStatus: "3" /* NativePlatformStatus.alreadyPrepared */ });
+        await this.$projectChangesService.setNativePlatformStatus(platformData, projectData, { nativePlatformStatus: constants_1.NativePlatformStatus.alreadyPrepared });
         return hasChanges;
     }
     async cleanProject(platformData, options) {
-        // android build artifacts need to be cleaned up
-        // when switching between debug, release and webpack builds
         if (platformData.platformNameLowerCase !== "android") {
             return;
         }
         const previousPrepareInfo = this.$projectChangesService.getPrepareInfo(platformData);
         if (!previousPrepareInfo ||
             previousPrepareInfo.nativePlatformStatus !==
-                "3" /* NativePlatformStatus.alreadyPrepared */) {
+                constants_1.NativePlatformStatus.alreadyPrepared) {
             return;
         }
         const { release: previousWasRelease } = previousPrepareInfo;
@@ -77,4 +76,3 @@ __decorate([
     (0, helpers_1.hook)("prepareNativeApp")
 ], PrepareNativePlatformService.prototype, "prepareNativePlatform", null);
 yok_1.injector.register("prepareNativePlatformService", PrepareNativePlatformService);
-//# sourceMappingURL=prepare-native-platform-service.js.map

package/lib/services/platform-environment-requirements.d.ts

@@ -0,0 +1,15 @@
+import { IPlatformEnvironmentRequirements, ICheckEnvironmentRequirementsInput, ICheckEnvironmentRequirementsOutput } from "../definitions/platform";
+import { IErrors, IAnalyticsService, IDoctorService } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+export declare class PlatformEnvironmentRequirements implements IPlatformEnvironmentRequirements {
+    private $doctorService;
+    private $errors;
+    private $analyticsService;
+    private $injector;
+    constructor($doctorService: IDoctorService, $errors: IErrors, $analyticsService: IAnalyticsService, $injector: IInjector);
+    private static MISSING_LOCAL_SETUP_MESSAGE;
+    checkEnvironmentRequirements(input: ICheckEnvironmentRequirementsInput): Promise<ICheckEnvironmentRequirementsOutput>;
+    private fail;
+    private getNonInteractiveConsoleMessage;
+    private getEnvVerificationMessage;
+}

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

@@ -7,13 +7,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlatformEnvironmentRequirements = void 0;
+const constants_1 = require("../constants");
 const helpers_1 = require("../common/helpers");
 const os_1 = require("os");
 const yok_1 = require("../common/yok");
 class PlatformEnvironmentRequirements {
-    constructor($doctorService, $errors, $analyticsService, 
-    // @ts-ignore - required by the hook helper!
-    $injector) {
+    constructor($doctorService, $errors, $analyticsService, $injector) {
         this.$doctorService = $doctorService;
         this.$errors = $errors;
         this.$analyticsService = $analyticsService;
@@ -24,7 +23,7 @@ class PlatformEnvironmentRequirements {
         const selectedOption = null;
         if (process.env.NS_SKIP_ENV_CHECK) {
             await this.$analyticsService.trackEventActionInGoogleAnalytics({
-                action: "Check Environment Requirements" /* TrackActionNames.CheckEnvironmentRequirements */,
+                action: constants_1.TrackActionNames.CheckEnvironmentRequirements,
                 additionalData: "Skipped: NS_SKIP_ENV_CHECK is set",
             });
             return {
@@ -39,9 +38,8 @@ class PlatformEnvironmentRequirements {
             forceCheck: input.forceCheck,
         });
         if (!canExecute) {
-            // if (!isInteractive()) {
             await this.$analyticsService.trackEventActionInGoogleAnalytics({
-                action: "Check Environment Requirements" /* TrackActionNames.CheckEnvironmentRequirements */,
+                action: constants_1.TrackActionNames.CheckEnvironmentRequirements,
                 additionalData: "Non-interactive terminal, unable to execute local builds.",
             });
             this.fail(this.getNonInteractiveConsoleMessage(platform));
@@ -61,7 +59,6 @@ class PlatformEnvironmentRequirements {
         ].join(os_1.EOL);
     }
     getEnvVerificationMessage(platform) {
-        // map process.platform to OS name used in docs
         const os = {
             linux: "linux",
             win32: "windows",
@@ -80,4 +77,3 @@ __decorate([
     (0, helpers_1.hook)("checkEnvironment")
 ], PlatformEnvironmentRequirements.prototype, "checkEnvironmentRequirements", null);
 yok_1.injector.register("platformEnvironmentRequirements", PlatformEnvironmentRequirements);
-//# sourceMappingURL=platform-environment-requirements.js.map

package/lib/services/platform-project-service-base.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from "events";
+import { IProjectDataService, IPlatformProjectServiceBase, IProjectData } from "../definitions/project";
+import { IPlatformData } from "../definitions/platform";
+import { IPluginData } from "../definitions/plugins";
+import { IFileSystem } from "../common/declarations";
+export declare abstract class PlatformProjectServiceBase extends EventEmitter implements IPlatformProjectServiceBase {
+    protected $fs: IFileSystem;
+    protected $projectDataService: IProjectDataService;
+    constructor($fs: IFileSystem, $projectDataService: IProjectDataService);
+    protected abstract getPlatformData(projectData: IProjectData): IPlatformData;
+    getPluginPlatformsFolderPath(pluginData: IPluginData, platform: string): string;
+    getFrameworkVersion(projectData: IProjectData): string;
+    protected getAllNativeLibrariesForPlugin(pluginData: IPluginData, platform: string, filter: (fileName: string, _pluginPlatformsFolderPath: string) => boolean): string[];
+}

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

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

package/lib/services/platforms-data-service.d.ts

@@ -0,0 +1,9 @@
+import { IProjectData } from "../definitions/project";
+import { IPlatformData, IPlatformsDataService } from "../definitions/platform";
+import { IOptions } from "../declarations";
+export declare class PlatformsDataService implements IPlatformsDataService {
+    private $options;
+    private platformsDataService;
+    constructor($options: IOptions, $androidProjectService: IPlatformProjectService, $iOSProjectService: IPlatformProjectService);
+    getPlatformData(platform: string, projectData: IProjectData): IPlatformData;
+}

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

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

package/lib/services/plugins-service.d.ts

@@ -0,0 +1,60 @@
+import { IPluginsService, IPreparePluginNativeCodeData, IPluginData, IPackageJsonDepedenciesResult } from "../definitions/plugins";
+import { INodeModulesDependenciesBuilder } from "../definitions/platform";
+import { IProjectData } from "../definitions/project";
+import { INodePackageManager, IOptions, IDependencyData } from "../declarations";
+import { IFileSystem, IErrors } from "../common/declarations";
+import { IFilesHashService } from "../definitions/files-hash-service";
+import { IInjector } from "../common/definitions/yok";
+export declare class PluginsService implements IPluginsService {
+    private $packageManager;
+    private $fs;
+    private $options;
+    private $logger;
+    private $errors;
+    private $filesHashService;
+    private $injector;
+    private $mobileHelper;
+    private $nodeModulesDependenciesBuilder;
+    private static INSTALL_COMMAND_NAME;
+    private static UNINSTALL_COMMAND_NAME;
+    private static NPM_CONFIG;
+    private static LOCK_FILES;
+    private get $platformsDataService();
+    private get $projectDataService();
+    private get npmInstallOptions();
+    constructor($packageManager: INodePackageManager, $fs: IFileSystem, $options: IOptions, $logger: ILogger, $errors: IErrors, $filesHashService: IFilesHashService, $injector: IInjector, $mobileHelper: Mobile.IMobileHelper, $nodeModulesDependenciesBuilder: INodeModulesDependenciesBuilder);
+    add(plugin: string, projectData: IProjectData): Promise<void>;
+    remove(pluginName: string, projectData: IProjectData): Promise<void>;
+    addToPackageJson(plugin: string, version: string, isDev: boolean, projectDir: string): void;
+    removeFromPackageJson(plugin: string, projectDir: string): void;
+    preparePluginNativeCode({ pluginData, platform, projectData, }: IPreparePluginNativeCodeData): Promise<void>;
+    ensureAllDependenciesAreInstalled(projectData: IProjectData): Promise<void>;
+    getAllInstalledPlugins(projectData: IProjectData): Promise<IPluginData[]>;
+    getAllProductionPlugins(projectData: IProjectData, platform: string, dependencies?: IDependencyData[]): IPluginData[];
+    getDependenciesFromPackageJson(projectDir: string): IPackageJsonDepedenciesResult;
+    isNativeScriptPlugin(pluginPackageJsonPath: string): boolean;
+    private ensureValidProductionPlugins;
+    private _ensureValidProductionPlugins;
+    private ensureValidProductionPluginsForAndroid;
+    private ensureValidProductionPluginsForIOS;
+    private getFailureMessageForDifferentDependencyVersions;
+    private getHelpMessage;
+    private convertToPluginData;
+    private removeDependencyFromPackageJsonContent;
+    private getBasicPluginInformation;
+    private getNodeModulesPath;
+    private getPackageJsonFilePath;
+    private getPackageJsonFilePathForModule;
+    private getDependencies;
+    private getNodeModuleData;
+    private ensure;
+    private getAllInstalledModules;
+    private executeNpmCommand;
+    private parseNpmCommandResult;
+    private executeForAllInstalledPlatforms;
+    private getInstalledFrameworkVersion;
+    private isPluginDataValidForPlatform;
+    private getPluginNativeHashes;
+    private getAllPluginsNativeHashes;
+    private setPluginNativeHashes;
+}

package/lib/services/plugins-service.js

@@ -54,7 +54,6 @@ class PluginsService {
         const realNpmPackageJson = this.$fs.readJson(pathToRealNpmPackageJson);
         if (realNpmPackageJson.nativescript) {
             const pluginData = this.convertToPluginData(realNpmPackageJson, projectData.projectDir);
-            // Validate
             const action = async (pluginDestinationPath, platform, platformData) => {
                 this.isPluginDataValidForPlatform(pluginData, platform, projectData);
             };
@@ -140,9 +139,6 @@ class PluginsService {
                 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`);
@@ -175,9 +171,6 @@ 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;
         });
     }
@@ -209,11 +202,9 @@ 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 {
@@ -243,11 +234,9 @@ 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);
@@ -257,7 +246,6 @@ 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}'.`));
@@ -309,7 +297,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" /* constants.PlatformTypes.ios */;
+                    platform = constants.PlatformTypes.ios;
                 }
                 return path.join(pluginData.fullPath, "platforms", platform.toLowerCase());
             };
@@ -367,7 +355,6 @@ 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") {
             const resolvedPath = this.getPackageJsonFilePathForModule(module, projectDir);
             if (!resolvedPath) {
@@ -404,7 +391,7 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
         return this.parseNpmCommandResult(npmCommandArguments);
     }
     parseNpmCommandResult(npmCommandResult) {
-        return npmCommandResult.split("@")[0]; // returns plugin name
+        return npmCommandResult.split("@")[0];
     }
     async executeForAllInstalledPlatforms(action, projectData) {
         const availablePlatforms = this.$mobileHelper.platformNames.map((p) => p.toLowerCase());
@@ -419,8 +406,6 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
     }
     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) {
@@ -450,7 +435,6 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
     }
     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 = {};
@@ -461,7 +445,6 @@ 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] =
@@ -482,4 +465,3 @@ PluginsService.LOCK_FILES = [
     "pnpm-lock.yaml",
 ];
 yok_1.injector.register("pluginsService", PluginsService);
-//# sourceMappingURL=plugins-service.js.map

package/lib/services/prepare-data-service.d.ts

@@ -0,0 +1,7 @@
+import { IOSPrepareData, AndroidPrepareData } from "../data/prepare-data";
+import { IOptions } from "../declarations";
+export declare class PrepareDataService implements IPrepareDataService {
+    private $mobileHelper;
+    constructor($mobileHelper: Mobile.IMobileHelper);
+    getPrepareData(projectDir: string, platform: string, data: IOptions): IOSPrepareData | AndroidPrepareData;
+}

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

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

package/lib/services/project-backup-service.d.ts

@@ -0,0 +1,12 @@
+import { IBackup, IProjectBackupService } from "../definitions/project";
+import { IFileSystem, IProjectHelper } from "../common/declarations";
+export declare class ProjectBackupService implements IProjectBackupService {
+    protected $fs: IFileSystem;
+    protected $logger: ILogger;
+    protected $projectHelper: IProjectHelper;
+    constructor($fs: IFileSystem, $logger: ILogger, $projectHelper: IProjectHelper);
+    getBackup(backupName: string): IBackup;
+    backup(name: string, pathsToBackup: string[]): IBackup;
+    restore(name: string): IBackup;
+    static Backup: new ($super: ProjectBackupService, name: string, pathsToBackup?: string[], basePath?: string) => IBackup;
+}

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

@@ -47,7 +47,6 @@ 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,
@@ -68,7 +67,6 @@ ProjectBackupService.Backup = class Backup {
             }
         }
         this.$super.$logger.trace(backupData);
-        // restore files
         return this;
     }
     isUpToDate() {
@@ -78,7 +76,6 @@ 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;
             }
@@ -115,4 +112,3 @@ ProjectBackupService.Backup = class Backup {
     }
 };
 yok_1.injector.register("projectBackupService", ProjectBackupService);
-//# sourceMappingURL=project-backup-service.js.map

package/lib/services/project-changes-service.d.ts

@@ -0,0 +1,30 @@
+import { INodeModulesDependenciesBuilder, IPlatformData } from "../definitions/platform";
+import { IProjectData } from "../definitions/project";
+import { IFileSystem, IHooksService } from "../common/declarations";
+import { IProjectChangesInfo, IPrepareInfo, IAddedNativePlatform } from "../definitions/project-changes";
+import { IOptions } from "../declarations";
+export declare class ProjectChangesService implements IProjectChangesService {
+    private $devicePlatformsConstants;
+    private $fs;
+    private $logger;
+    private $options;
+    $hooksService: IHooksService;
+    private $nodeModulesDependenciesBuilder;
+    private _changesInfo;
+    private _prepareInfo;
+    private _outputProjectMtime;
+    private _outputProjectCTime;
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $fs: IFileSystem, $logger: ILogger, $options: IOptions, $hooksService: IHooksService, $nodeModulesDependenciesBuilder: INodeModulesDependenciesBuilder);
+    get currentChanges(): IProjectChangesInfo;
+    checkForChanges(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<IProjectChangesInfo>;
+    getPrepareInfoFilePath(platformData: IPlatformData): string;
+    getPrepareInfo(platformData: IPlatformData): IPrepareInfo;
+    savePrepareInfo(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<void>;
+    setNativePlatformStatus(platformData: IPlatformData, projectData: IProjectData, addedPlatform: IAddedNativePlatform): Promise<void>;
+    private ensurePrepareInfo;
+    private getProjectFileStrippedHash;
+    private isProjectFileChanged;
+    private filesChanged;
+    private containsNewerFiles;
+    private isFileModified;
+}

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

@@ -64,7 +64,6 @@ class ProjectChangesService {
                 this._prepareInfo.projectFileHash = this.getProjectFileStrippedHash(projectData.projectDir, platformData);
                 this._changesInfo.nativeChanged = this.isProjectFileChanged(projectData.projectDir, platformData);
             }
-            // If this causes too much rebuilds of the plugins or uncecessary builds for Android, move overrideCocoapods to prepareInfo.
             this._changesInfo.nsConfigChanged = this.filesChanged([
                 path.join(projectData.projectDir, constants_1.CONFIG_FILE_NAME_JS),
                 path.join(projectData.projectDir, constants_1.CONFIG_FILE_NAME_TS),
@@ -122,7 +121,6 @@ class ProjectChangesService {
     }
     getPrepareInfo(platformData) {
         if (this.$options.hostProjectPath) {
-            // TODO: always prepare for now until we decide where to keep the .nsprepareinfo file when embedding
             return null;
         }
         const prepareInfoFilePath = this.getPrepareInfoFilePath(platformData);
@@ -142,7 +140,6 @@ class ProjectChangesService {
             await this.ensurePrepareInfo(platformData, projectData, prepareData);
         }
         if (this.$options.hostProjectPath) {
-            // TODO: do not save for now until we decide where to keep the .nsprepareinfo file when embedding
             return null;
         }
         const prepareInfoFilePath = this.getPrepareInfoFilePath(platformData);
@@ -152,7 +149,7 @@ class ProjectChangesService {
         this._prepareInfo = this._prepareInfo || this.getPrepareInfo(platformData);
         if (this._prepareInfo &&
             addedPlatform.nativePlatformStatus ===
-                "3" /* NativePlatformStatus.alreadyPrepared */) {
+                constants_1.NativePlatformStatus.alreadyPrepared) {
             this._prepareInfo.nativePlatformStatus =
                 addedPlatform.nativePlatformStatus;
         }
@@ -176,8 +173,8 @@ class ProjectChangesService {
             return false;
         }
         const nativePlatformStatus = !prepareData.nativePrepare || !prepareData.nativePrepare.skipNativePrepare
-            ? "2" /* NativePlatformStatus.requiresPrepare */
-            : "1" /* NativePlatformStatus.requiresPlatformAdd */;
+            ? constants_1.NativePlatformStatus.requiresPrepare
+            : constants_1.NativePlatformStatus.requiresPlatformAdd;
         this._prepareInfo = {
             time: "",
             nativePlatformStatus,
@@ -200,13 +197,6 @@ class ProjectChangesService {
         const projectFileContents = this.$fs.readJson(projectFilePath);
         const relevantProperties = ["dependencies"];
         const projectFileStrippedContents = _.pick(projectFileContents, relevantProperties);
-        // _(this.$devicePlatformsConstants)
-        // 	.keys()
-        // 	.map(k => k.toLowerCase())
-        // 	.difference([platformData.platformNameLowerCase])
-        // 	.each(otherPlatform => {
-        // 		delete projectFileContents.nativescript[`tns-${otherPlatform}`];
-        // 	});
         return (0, helpers_1.getHash)(JSON.stringify(projectFileStrippedContents));
     }
     isProjectFileChanged(projectDir, platformData) {
@@ -272,4 +262,3 @@ __decorate([
     (0, helpers_1.hook)("checkForChanges")
 ], ProjectChangesService.prototype, "checkForChanges", null);
 yok_1.injector.register("projectChangesService", ProjectChangesService);
-//# sourceMappingURL=project-changes-service.js.map

package/lib/services/project-cleanup-service.d.ts

@@ -0,0 +1,13 @@
+import { IProjectCleanupOptions, IProjectCleanupResult, IProjectCleanupService, IProjectPathCleanupResult } from "../definitions/project";
+import { IFileSystem, IProjectHelper } from "../common/declarations";
+import { ITerminalSpinnerService } from "../definitions/terminal-spinner-service";
+export declare class ProjectCleanupService implements IProjectCleanupService {
+    private $fs;
+    private $logger;
+    private $projectHelper;
+    private $terminalSpinnerService;
+    private spinner;
+    constructor($fs: IFileSystem, $logger: ILogger, $projectHelper: IProjectHelper, $terminalSpinnerService: ITerminalSpinnerService);
+    clean(pathsToClean: string[], options?: IProjectCleanupOptions): Promise<IProjectCleanupResult>;
+    cleanPath(pathToClean: string, options?: IProjectCleanupOptions): Promise<IProjectPathCleanupResult>;
+}