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

package/lib/services/pacote-service.js

@@ -5,6 +5,15 @@ 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.PacoteService = void 0;
 const pacote = require("pacote");
@@ -24,60 +33,72 @@ class PacoteService {
         this.$proxyService = $proxyService;
     }
     get $packageManager() {
+        // need to be resolved here due to cyclic dependency
         return this.$injector.resolve("packageManager");
     }
-    async manifest(packageName, options) {
-        this.$logger.trace(`Calling pacoteService.manifest for packageName: '${packageName}' and options: `, options);
-        const manifestOptions = await this.getPacoteBaseOptions();
-        if (options) {
-            _.extend(manifestOptions, options);
-        }
-        packageName = this.getRealPackageName(packageName);
-        this.$logger.trace(`Calling pacote.manifest for packageName: ${packageName} and manifestOptions:`, manifestOptions);
-        const result = await pacote.manifest(packageName, manifestOptions);
-        this.$logger.trace("pacote.manifest result:", result);
-        return result;
+    manifest(packageName, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace(`Calling pacoteService.manifest for packageName: '${packageName}' and options: `, options);
+            const manifestOptions = yield this.getPacoteBaseOptions();
+            if (options) {
+                _.extend(manifestOptions, options);
+            }
+            packageName = this.getRealPackageName(packageName);
+            this.$logger.trace(`Calling pacote.manifest for packageName: ${packageName} and manifestOptions:`, manifestOptions);
+            const result = yield pacote.manifest(packageName, manifestOptions);
+            this.$logger.trace("pacote.manifest result:", result);
+            return result;
+        });
     }
-    async extractPackage(packageName, destinationDirectory, options) {
-        this.$logger.trace(`Calling pacoteService.extractPackage for packageName: '${packageName}', destinationDir: '${destinationDirectory}' and options: ${options}`);
-        const extractOptions = { strip: 1, C: destinationDirectory };
-        if (options) {
-            _.extend(extractOptions, options);
-        }
-        packageName = this.getRealPackageName(packageName);
-        const pacoteOptions = await this.getPacoteBaseOptions();
-        return new Promise(async (resolve, reject) => {
+    extractPackage(packageName, destinationDirectory, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // strip: Remove the specified number of leading path elements. Pathnames with fewer elements will be silently skipped. More info: https://github.com/npm/node-tar/blob/e89c4d37519b1c20133a9f49d5f6b85fa34c203b/README.md
+            // C: Create an archive
             this.$logger.trace(`Calling pacoteService.extractPackage for packageName: '${packageName}', destinationDir: '${destinationDirectory}' and options: ${options}`);
-            const source = await pacote
-                .tarball(packageName, pacoteOptions)
-                .catch((err) => {
-                this.$logger.trace(`Error in source while trying to extract stream from ${packageName}. Error is ${err}`);
-                reject(err);
-            });
-            this.$logger.trace(`Creating extract tar stream with options: ${JSON.stringify(extractOptions, null, 2)}`);
-            const destination = tar.x(extractOptions);
-            const sourceStream = new stream_1.PassThrough();
-            sourceStream.end(source);
-            sourceStream.pipe(destination);
-            destination.on("error", (err) => {
-                this.$logger.trace(`Error in destination while trying to extract stream from ${packageName}. Error is ${err}`);
-                reject(err);
-            });
-            destination.on("finish", () => {
-                this.$logger.trace(`Successfully extracted '${packageName}' to ${destinationDirectory}`);
-                resolve();
-            });
+            const extractOptions = { strip: 1, C: destinationDirectory };
+            if (options) {
+                _.extend(extractOptions, options);
+            }
+            packageName = this.getRealPackageName(packageName);
+            const pacoteOptions = yield this.getPacoteBaseOptions();
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.$logger.trace(`Calling pacoteService.extractPackage for packageName: '${packageName}', destinationDir: '${destinationDirectory}' and options: ${options}`);
+                const source = yield pacote
+                    .tarball(packageName, pacoteOptions)
+                    .catch((err) => {
+                    this.$logger.trace(`Error in source while trying to extract stream from ${packageName}. Error is ${err}`);
+                    reject(err);
+                });
+                this.$logger.trace(`Creating extract tar stream with options: ${JSON.stringify(extractOptions, null, 2)}`);
+                const destination = tar.x(extractOptions);
+                // Initiate the source
+                const sourceStream = new stream_1.PassThrough();
+                sourceStream.end(source);
+                sourceStream.pipe(destination);
+                destination.on("error", (err) => {
+                    this.$logger.trace(`Error in destination while trying to extract stream from ${packageName}. Error is ${err}`);
+                    reject(err);
+                });
+                destination.on("finish", () => {
+                    this.$logger.trace(`Successfully extracted '${packageName}' to ${destinationDirectory}`);
+                    resolve();
+                });
+            }));
         });
     }
-    async getPacoteBaseOptions() {
-        const cachePath = await this.$packageManager.getCachePath();
-        const npmConfig = this.$npmConfigService.getConfig();
-        const pacoteOptions = _.extend(npmConfig, { cache: cachePath, Arborist: arborist_1.Arborist });
-        const proxySettings = await this.$proxyService.getCache();
-        if (proxySettings) {
-            _.extend(pacoteOptions, proxySettings);
-        }
-        return pacoteOptions;
+    getPacoteBaseOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // In case `tns create myapp --template https://github.com/NativeScript/template-hello-world.git` command is executed, pacote module throws an error if cache option is not provided.
+            const cachePath = yield this.$packageManager.getCachePath();
+            // Add NPM Configuration to our Manifest options
+            const npmConfig = this.$npmConfigService.getConfig();
+            const pacoteOptions = _.extend(npmConfig, { cache: cachePath, Arborist: arborist_1.Arborist });
+            const proxySettings = yield this.$proxyService.getCache();
+            if (proxySettings) {
+                _.extend(pacoteOptions, proxySettings);
+            }
+            return pacoteOptions;
+        });
     }
     getRealPackageName(packageName) {
         if (this.$fs.exists(packageName)) {
@@ -87,8 +108,9 @@ class PacoteService {
         return packageName;
     }
 }
-exports.PacoteService = PacoteService;
 __decorate([
     (0, decorators_1.cache)()
 ], PacoteService.prototype, "$packageManager", null);
+exports.PacoteService = PacoteService;
 yok_1.injector.register("pacoteService", PacoteService);
+//# sourceMappingURL=pacote-service.js.map

package/lib/services/performance-service.js

@@ -41,7 +41,7 @@ class PerformanceService {
     trackAnalyticsData(methodInfo, executionTime) {
         this.$analyticsService
             .trackEventActionInGoogleAnalytics({
-            action: "Performance",
+            action: "Performance" /* TrackActionNames.Performance */,
             additionalData: methodInfo,
             value: executionTime,
         })
@@ -71,6 +71,7 @@ class PerformanceService {
             this.$logger.info(PerformanceService.LOG_MESSAGE_TEMPLATE, methodInfo, executionTime);
         }
     }
+    //removes any injected members of the arguments and excludes the options object even if it was renamed
     getJsonSanitizer() {
         const seen = new WeakSet();
         seen.add(this.$options);
@@ -85,8 +86,9 @@ class PerformanceService {
         };
     }
 }
-exports.PerformanceService = PerformanceService;
 PerformanceService.LOG_MESSAGE_TEMPLATE = `Execution of method "%s" took %s ms.`;
 PerformanceService.FAIL_LOG_MESSAGE_TEMPLATE = `Failed to log pefromance data in file for method %s.`;
 PerformanceService.MIN_NODE_PERFORMANCE_MODULE_VERSION = "8.5.0";
+exports.PerformanceService = PerformanceService;
 yok_1.injector.register("performanceService", PerformanceService);
+//# sourceMappingURL=performance-service.js.map

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

@@ -5,6 +5,15 @@ 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.AddPlatformService = void 0;
 const path = require("path");
@@ -12,7 +21,11 @@ const constants_1 = require("../../constants");
 const decorators_1 = require("../../common/decorators");
 const yok_1 = require("../../common/yok");
 class AddPlatformService {
-    constructor($fs, $logger, $options, $packageManager, $terminalSpinnerService, $analyticsService) {
+    constructor($fs, $logger, $options, 
+    // private $pacoteService: IPacoteService,
+    // private $projectDataService: IProjectDataService,
+    $packageManager, $terminalSpinnerService, $analyticsService // private $tempService: ITempService
+    ) {
         this.$fs = $fs;
         this.$logger = $logger;
         this.$options = $options;
@@ -20,51 +33,99 @@ class AddPlatformService {
         this.$terminalSpinnerService = $terminalSpinnerService;
         this.$analyticsService = $analyticsService;
     }
-    async addProjectHost() { }
-    async addPlatformSafe(projectData, platformData, packageToInstall, addPlatformData) {
-        const spinner = this.$terminalSpinnerService.createSpinner();
-        try {
-            spinner.start();
-            const frameworkDirPath = await this.installPackage(projectData.projectDir, packageToInstall);
-            const frameworkPackageJsonContent = this.$fs.readJson(path.join(frameworkDirPath, "..", "package.json"));
-            const frameworkVersion = frameworkPackageJsonContent.version;
-            await this.trackPlatformVersion(frameworkVersion, platformData);
-            if (!addPlatformData.nativePrepare ||
-                !addPlatformData.nativePrepare.skipNativePrepare) {
-                await this.addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion);
+    addProjectHost() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    addPlatformSafe(projectData, platformData, packageToInstall, addPlatformData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spinner = this.$terminalSpinnerService.createSpinner();
+            try {
+                spinner.start();
+                // const frameworkDirPath = addPlatformData.frameworkPath ?
+                // 	await this.extractPackage(packageToInstall)
+                // 	: await this.installPackage(projectData.projectDir, packageToInstall);
+                const frameworkDirPath = yield 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);
+                yield this.trackPlatformVersion(frameworkVersion, platformData);
+                if (!addPlatformData.nativePrepare ||
+                    !addPlatformData.nativePrepare.skipNativePrepare) {
+                    yield this.addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion);
+                }
+                return frameworkVersion;
             }
-            return frameworkVersion;
-        }
-        catch (err) {
-            const platformPath = path.join(projectData.platformsDir, platformData.platformNameLowerCase);
-            this.$fs.deleteDirectory(platformPath);
-            throw err;
-        }
-        finally {
-            spinner.stop();
-        }
+            catch (err) {
+                const platformPath = path.join(projectData.platformsDir, platformData.platformNameLowerCase);
+                this.$fs.deleteDirectory(platformPath);
+                throw err;
+            }
+            finally {
+                spinner.stop();
+            }
+        });
     }
-    async setPlatformVersion(platformData, projectData, frameworkVersion) {
-        await this.installPackage(projectData.projectDir, `${platformData.frameworkPackageName}@${frameworkVersion}`);
+    setPlatformVersion(platformData, projectData, frameworkVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.installPackage(projectData.projectDir, `${platformData.frameworkPackageName}@${frameworkVersion}`);
+        });
     }
-    async installPackage(projectDir, packageName) {
-        const frameworkDir = this.resolveFrameworkDir(projectDir, packageName);
-        if (frameworkDir && this.$fs.exists(frameworkDir)) {
-            return frameworkDir;
-        }
-        const installedPackage = await this.$packageManager.install(packageName, projectDir, {
-            silent: true,
-            dev: true,
-            "save-dev": true,
-            "save-exact": true,
+    // 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);
+    // }
+    installPackage(projectDir, packageName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const frameworkDir = this.resolveFrameworkDir(projectDir, packageName);
+            if (frameworkDir && this.$fs.exists(frameworkDir)) {
+                // don't install if it's already installed
+                return frameworkDir;
+            }
+            const installedPackage = yield this.$packageManager.install(packageName, projectDir, {
+                silent: true,
+                dev: true,
+                "save-dev": true,
+                "save-exact": true,
+            });
+            if (!installedPackage.name) {
+                return "";
+            }
+            return this.resolveFrameworkDir(projectDir, installedPackage.name) || "";
         });
-        if (!installedPackage.name) {
-            return "";
-        }
-        return this.resolveFrameworkDir(projectDir, installedPackage.name) || "";
     }
     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`, {
@@ -80,24 +141,31 @@ class AddPlatformService {
         }
         return null;
     }
-    async addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion) {
+    addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion) {
         var _a;
-        const platformDir = (_a = this.$options.hostProjectPath) !== null && _a !== void 0 ? _a : path.join(projectData.platformsDir, platformData.normalizedPlatformName.toLowerCase());
-        this.$fs.deleteDirectory(platformDir);
-        await platformData.platformProjectService.createProject(path.resolve(frameworkDirPath), frameworkVersion, projectData);
-        platformData.platformProjectService.ensureConfigurationFileInAppResources(projectData);
-        await platformData.platformProjectService.interpolateData(projectData);
-        platformData.platformProjectService.afterCreateProject(platformData.projectRoot, projectData);
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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
+            yield platformData.platformProjectService.createProject(path.resolve(frameworkDirPath), frameworkVersion, projectData);
+            platformData.platformProjectService.ensureConfigurationFileInAppResources(projectData);
+            yield platformData.platformProjectService.interpolateData(projectData);
+            platformData.platformProjectService.afterCreateProject(platformData.projectRoot, projectData);
+        });
     }
-    async trackPlatformVersion(frameworkVersion, platformData) {
-        await this.$analyticsService.trackEventActionInGoogleAnalytics({
-            action: "Add Platform",
-            additionalData: `${platformData.platformNameLowerCase}${constants_1.AnalyticsEventLabelDelimiter}${frameworkVersion}`,
+    trackPlatformVersion(frameworkVersion, platformData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Add Platform" /* TrackActionNames.AddPlatform */,
+                additionalData: `${platformData.platformNameLowerCase}${constants_1.AnalyticsEventLabelDelimiter}${frameworkVersion}`,
+            });
         });
     }
 }
-exports.AddPlatformService = AddPlatformService;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], AddPlatformService.prototype, "addNativePlatform", null);
+exports.AddPlatformService = AddPlatformService;
 yok_1.injector.register("addPlatformService", AddPlatformService);
+//# sourceMappingURL=add-platform-service.js.map

package/lib/services/platform/platform-validation-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.PlatformValidationService = void 0;
 const helpers = require("../../common/helpers");
@@ -38,29 +47,31 @@ class PlatformValidationService {
             this.$errors.fail("The platform %s is not added to this project. Please use 'ns platform add <platform>'", platform);
         }
     }
-    async validateOptions(provision, teamId, projectData, platform, aab) {
-        if (platform && !this.$mobileHelper.isAndroidPlatform(platform) && aab) {
-            this.$errors.fail("The --aab option is supported only for the Android platform.");
-        }
-        if (platform) {
-            platform = this.$mobileHelper.normalizePlatformName(platform);
-            this.$logger.trace("Validate options for platform: " + platform);
-            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
-            const result = await platformData.platformProjectService.validateOptions(projectData.projectIdentifiers[platform.toLowerCase()], provision, teamId);
-            return result;
-        }
-        else {
-            let valid = true;
-            const platforms = this.$mobileHelper.platformNames.map((p) => p.toLowerCase());
-            for (const availablePlatform of platforms) {
-                this.$logger.trace("Validate options for platform: " + availablePlatform);
-                const platformData = this.$platformsDataService.getPlatformData(availablePlatform, projectData);
-                valid =
-                    valid &&
-                        (await platformData.platformProjectService.validateOptions(projectData.projectIdentifiers[availablePlatform.toLowerCase()], provision, teamId));
+    validateOptions(provision, teamId, projectData, platform, aab) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (platform && !this.$mobileHelper.isAndroidPlatform(platform) && aab) {
+                this.$errors.fail("The --aab option is supported only for the Android platform.");
             }
-            return valid;
-        }
+            if (platform) {
+                platform = this.$mobileHelper.normalizePlatformName(platform);
+                this.$logger.trace("Validate options for platform: " + platform);
+                const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+                const result = yield platformData.platformProjectService.validateOptions(projectData.projectIdentifiers[platform.toLowerCase()], provision, teamId);
+                return result;
+            }
+            else {
+                let valid = true;
+                const platforms = this.$mobileHelper.platformNames.map((p) => p.toLowerCase());
+                for (const availablePlatform of platforms) {
+                    this.$logger.trace("Validate options for platform: " + availablePlatform);
+                    const platformData = this.$platformsDataService.getPlatformData(availablePlatform, projectData);
+                    valid =
+                        valid &&
+                            (yield platformData.platformProjectService.validateOptions(projectData.projectIdentifiers[availablePlatform.toLowerCase()], provision, teamId));
+                }
+                return valid;
+            }
+        });
     }
     isPlatformSupportedForOS(platform, projectData) {
         const targetedOS = this.$platformsDataService.getPlatformData(platform, projectData).targetedOS;
@@ -72,3 +83,4 @@ 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.js

@@ -5,6 +5,15 @@ 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.PrepareNativePlatformService = void 0;
 const helpers_1 = require("../../common/helpers");
@@ -18,60 +27,67 @@ class PrepareNativePlatformService {
         this.$metadataFilteringService = $metadataFilteringService;
         this.$options = $options;
     }
-    async prepareNativePlatform(platformData, projectData, prepareData) {
-        const { nativePrepare, release } = prepareData;
-        const changesInfo = await this.$projectChangesService.checkForChanges(platformData, projectData, prepareData);
-        if (nativePrepare && nativePrepare.skipNativePrepare) {
-            return changesInfo.hasChanges;
-        }
-        const hasNativeModulesChange = !changesInfo || changesInfo.nativeChanged;
-        const hasConfigChange = !changesInfo || changesInfo.configChanged;
-        const hasChangesRequirePrepare = !changesInfo || changesInfo.changesRequirePrepare;
-        const hasChanges = hasNativeModulesChange || hasConfigChange || hasChangesRequirePrepare;
-        if (changesInfo.hasChanges) {
-            await this.cleanProject(platformData, { release });
-        }
-        if (!this.$options.hostProjectPath) {
-            platformData.platformProjectService.prepareAppResources(projectData);
-        }
-        if (hasChangesRequirePrepare || this.$options.hostProjectPath) {
-            await platformData.platformProjectService.prepareProject(projectData, prepareData);
-        }
-        if (hasNativeModulesChange) {
-            await this.$nodeModulesBuilder.prepareNodeModules({
-                platformData,
-                projectData,
-            });
-        }
-        if (hasNativeModulesChange || hasConfigChange) {
-            await platformData.platformProjectService.processConfigurationFilesFromAppResources(projectData, { release });
-            await platformData.platformProjectService.handleNativeDependenciesChange(projectData, { release });
-            this.$metadataFilteringService.generateMetadataFilters(projectData, platformData.platformNameLowerCase);
-        }
-        platformData.platformProjectService.interpolateConfigurationFile(projectData);
-        await this.$projectChangesService.setNativePlatformStatus(platformData, projectData, { nativePlatformStatus: "3" });
-        return hasChanges;
+    prepareNativePlatform(platformData, projectData, prepareData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { nativePrepare, release } = prepareData;
+            const changesInfo = yield this.$projectChangesService.checkForChanges(platformData, projectData, prepareData);
+            if (nativePrepare && nativePrepare.skipNativePrepare) {
+                return changesInfo.hasChanges;
+            }
+            const hasNativeModulesChange = !changesInfo || changesInfo.nativeChanged;
+            const hasConfigChange = !changesInfo || changesInfo.configChanged;
+            const hasChangesRequirePrepare = !changesInfo || changesInfo.changesRequirePrepare;
+            const hasChanges = hasNativeModulesChange || hasConfigChange || hasChangesRequirePrepare;
+            if (changesInfo.hasChanges) {
+                yield this.cleanProject(platformData, { release });
+            }
+            if (!this.$options.hostProjectPath) {
+                platformData.platformProjectService.prepareAppResources(projectData);
+            }
+            if (hasChangesRequirePrepare || this.$options.hostProjectPath) {
+                yield platformData.platformProjectService.prepareProject(projectData, prepareData);
+            }
+            if (hasNativeModulesChange) {
+                yield this.$nodeModulesBuilder.prepareNodeModules({
+                    platformData,
+                    projectData,
+                });
+            }
+            if (hasNativeModulesChange || hasConfigChange) {
+                yield platformData.platformProjectService.processConfigurationFilesFromAppResources(projectData, { release });
+                yield platformData.platformProjectService.handleNativeDependenciesChange(projectData, { release });
+                this.$metadataFilteringService.generateMetadataFilters(projectData, platformData.platformNameLowerCase);
+            }
+            platformData.platformProjectService.interpolateConfigurationFile(projectData);
+            yield this.$projectChangesService.setNativePlatformStatus(platformData, projectData, { nativePlatformStatus: "3" /* NativePlatformStatus.alreadyPrepared */ });
+            return hasChanges;
+        });
     }
-    async cleanProject(platformData, options) {
-        if (platformData.platformNameLowerCase !== "android") {
-            return;
-        }
-        const previousPrepareInfo = this.$projectChangesService.getPrepareInfo(platformData);
-        if (!previousPrepareInfo ||
-            previousPrepareInfo.nativePlatformStatus !==
-                "3") {
-            return;
-        }
-        const { release: previousWasRelease } = previousPrepareInfo;
-        const { release: currentIsRelease } = options;
-        if (previousWasRelease !== currentIsRelease) {
-            await platformData.platformProjectService.cleanProject(platformData.projectRoot);
-        }
+    cleanProject(platformData, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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 */) {
+                return;
+            }
+            const { release: previousWasRelease } = previousPrepareInfo;
+            const { release: currentIsRelease } = options;
+            if (previousWasRelease !== currentIsRelease) {
+                yield platformData.platformProjectService.cleanProject(platformData.projectRoot);
+            }
+        });
     }
 }
-exports.PrepareNativePlatformService = PrepareNativePlatformService;
 __decorate([
     (0, decorators_1.performanceLog)(),
     (0, helpers_1.hook)("prepareNativeApp")
 ], PrepareNativePlatformService.prototype, "prepareNativePlatform", null);
+exports.PrepareNativePlatformService = PrepareNativePlatformService;
 yok_1.injector.register("prepareNativePlatformService", PrepareNativePlatformService);
+//# sourceMappingURL=prepare-native-platform-service.js.map