@akylas/nativescript-cli 8.7.2 → 8.8.3

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

@@ -5,15 +5,6 @@ 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");
@@ -21,60 +12,56 @@ const constants_1 = require("../../constants");
 const decorators_1 = require("../../common/decorators");
 const yok_1 = require("../../common/yok");
 class AddPlatformService {
-    constructor($fs, $logger, $packageManager, $terminalSpinnerService, $analyticsService) {
+    constructor($fs, $logger, $options, $packageManager, $terminalSpinnerService, $analyticsService) {
         this.$fs = $fs;
         this.$logger = $logger;
+        this.$options = $options;
         this.$packageManager = $packageManager;
         this.$terminalSpinnerService = $terminalSpinnerService;
         this.$analyticsService = $analyticsService;
     }
-    addPlatformSafe(projectData, platformData, packageToInstall, addPlatformData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const spinner = this.$terminalSpinnerService.createSpinner();
-            try {
-                spinner.start();
-                const frameworkDirPath = yield this.installPackage(projectData.projectDir, packageToInstall);
-                const frameworkPackageJsonContent = this.$fs.readJson(path.join(frameworkDirPath, "..", "package.json"));
-                const frameworkVersion = frameworkPackageJsonContent.version;
-                yield this.trackPlatformVersion(frameworkVersion, platformData);
-                if (!addPlatformData.nativePrepare ||
-                    !addPlatformData.nativePrepare.skipNativePrepare) {
-                    yield this.addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion);
-                }
-                return frameworkVersion;
-            }
-            catch (err) {
-                const platformPath = path.join(projectData.platformsDir, platformData.platformNameLowerCase);
-                this.$fs.deleteDirectory(platformPath);
-                throw err;
-            }
-            finally {
-                spinner.stop();
+    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);
             }
-        });
+            return frameworkVersion;
+        }
+        catch (err) {
+            const platformPath = path.join(projectData.platformsDir, platformData.platformNameLowerCase);
+            this.$fs.deleteDirectory(platformPath);
+            throw err;
+        }
+        finally {
+            spinner.stop();
+        }
     }
-    setPlatformVersion(platformData, projectData, frameworkVersion) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.installPackage(projectData.projectDir, `${platformData.frameworkPackageName}@${frameworkVersion}`);
-        });
+    async setPlatformVersion(platformData, projectData, frameworkVersion) {
+        await this.installPackage(projectData.projectDir, `${platformData.frameworkPackageName}@${frameworkVersion}`);
     }
-    installPackage(projectDir, packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const frameworkDir = this.resolveFrameworkDir(projectDir, packageName);
-            if (frameworkDir && this.$fs.exists(frameworkDir)) {
-                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) || "";
+    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,
         });
+        if (!installedPackage.name) {
+            return "";
+        }
+        return this.resolveFrameworkDir(projectDir, installedPackage.name) || "";
     }
     resolveFrameworkDir(projectDir, packageName) {
         try {
@@ -93,27 +80,24 @@ class AddPlatformService {
         }
         return null;
     }
-    addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const platformDir = path.join(projectData.platformsDir, platformData.normalizedPlatformName.toLowerCase());
-            this.$fs.deleteDirectory(platformDir);
-            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 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);
     }
-    trackPlatformVersion(frameworkVersion, platformData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
-                action: "Add Platform",
-                additionalData: `${platformData.platformNameLowerCase}${constants_1.AnalyticsEventLabelDelimiter}${frameworkVersion}`,
-            });
+    async trackPlatformVersion(frameworkVersion, platformData) {
+        await this.$analyticsService.trackEventActionInGoogleAnalytics({
+            action: "Add Platform",
+            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);

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

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlatformValidationService = void 0;
 const helpers = require("../../common/helpers");
@@ -47,31 +38,29 @@ class PlatformValidationService {
             this.$errors.fail("The platform %s is not added to this project. Please use 'ns platform add <platform>'", platform);
         }
     }
-    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.");
-            }
-            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;
+    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));
             }
-        });
+            return valid;
+        }
     }
     isPlatformSupportedForOS(platform, projectData) {
         const targetedOS = this.$platformsDataService.getPlatformData(platform, projectData).targetedOS;

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

@@ -5,83 +5,73 @@ 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");
 const decorators_1 = require("../../common/decorators");
 const yok_1 = require("../../common/yok");
 class PrepareNativePlatformService {
-    constructor($hooksService, $nodeModulesBuilder, $projectChangesService, $metadataFilteringService) {
+    constructor($hooksService, $nodeModulesBuilder, $projectChangesService, $metadataFilteringService, $options) {
         this.$hooksService = $hooksService;
         this.$nodeModulesBuilder = $nodeModulesBuilder;
         this.$projectChangesService = $projectChangesService;
         this.$metadataFilteringService = $metadataFilteringService;
+        this.$options = $options;
     }
-    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 });
-            }
+    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) {
-                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" });
-            return hasChanges;
-        });
+        }
+        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;
     }
-    cleanProject(platformData, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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) {
-                yield platformData.platformProjectService.cleanProject(platformData.projectRoot);
-            }
-        });
+    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);
+        }
     }
 }
+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);

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

@@ -5,15 +5,6 @@ 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");
@@ -26,38 +17,36 @@ class PlatformEnvironmentRequirements {
         this.$analyticsService = $analyticsService;
         this.$injector = $injector;
     }
-    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",
-                    additionalData: "Skipped: NS_SKIP_ENV_CHECK is set",
-                });
-                return {
-                    canExecute: true,
-                    selectedOption,
-                };
-            }
-            const canExecute = yield this.$doctorService.canExecuteLocalBuild({
-                platform,
-                projectDir,
-                runtimeVersion,
-                forceCheck: input.forceCheck,
+    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",
             });
-            if (!canExecute) {
-                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
-                    action: "Check Environment Requirements",
-                    additionalData: "Non-interactive terminal, unable to execute local builds.",
-                });
-                this.fail(this.getNonInteractiveConsoleMessage(platform));
-            }
             return {
-                canExecute,
+                canExecute: true,
                 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 });
@@ -74,14 +63,16 @@ class PlatformEnvironmentRequirements {
             win32: "windows",
             darwin: "macos",
         }[process.platform];
-        const anchor = platform ? `#setting-up-${os}-for-${platform.toLowerCase()}` : "";
+        const anchor = platform
+            ? `#setting-up-${os}-for-${platform.toLowerCase()}`
+            : "";
         return (`Verify that your environment is configured according to the system requirements described at\n` +
             `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);