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

package/lib/helpers/network-connectivity-validator.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.NetworkConnectivityValidator = void 0;
 const dns = require("dns");
@@ -8,11 +17,13 @@ class NetworkConnectivityValidator {
         this.$errors = $errors;
         this.$logger = $logger;
     }
-    async validate() {
-        const isConnected = await this.isConnected();
-        if (!isConnected) {
-            this.$errors.fail(NetworkConnectivityValidator.NO_INTERNET_ERROR_MESSAGE);
-        }
+    validate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isConnected = yield this.isConnected();
+            if (!isConnected) {
+                this.$errors.fail(NetworkConnectivityValidator.NO_INTERNET_ERROR_MESSAGE);
+            }
+        });
     }
     isConnected() {
         return new Promise((resolve, reject) => {
@@ -29,8 +40,9 @@ class NetworkConnectivityValidator {
         });
     }
 }
-exports.NetworkConnectivityValidator = NetworkConnectivityValidator;
 NetworkConnectivityValidator.DNS_LOOKUP_URL = "play.nativescript.org";
 NetworkConnectivityValidator.NO_INTERNET_ERROR_CODE = "ENOTFOUND";
 NetworkConnectivityValidator.NO_INTERNET_ERROR_MESSAGE = "No internet connection. Check your internet settings and try again.";
+exports.NetworkConnectivityValidator = NetworkConnectivityValidator;
 yok_1.injector.register("networkConnectivityValidator", NetworkConnectivityValidator);
+//# sourceMappingURL=network-connectivity-validator.js.map

package/lib/helpers/options-track-helper.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.OptionsTracker = void 0;
 const path = require("path");
@@ -8,11 +17,13 @@ class OptionsTracker {
     constructor($analyticsService) {
         this.$analyticsService = $analyticsService;
     }
-    async trackOptions(options) {
-        const trackObject = this.getTrackObject(options);
-        await this.$analyticsService.trackEventActionInGoogleAnalytics({
-            action: "Options",
-            additionalData: JSON.stringify(trackObject),
+    trackOptions(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trackObject = this.getTrackObject(options);
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Options" /* TrackActionNames.Options */,
+                additionalData: JSON.stringify(trackObject),
+            });
         });
     }
     getTrackObject(options) {
@@ -58,7 +69,7 @@ class OptionsTracker {
             return true;
         }
         const optionDef = options[key];
-        if (optionDef && optionDef.type === "boolean") {
+        if (optionDef && optionDef.type === "boolean" /* OptionType.Boolean */) {
             if ((optionDef.default !== true && value === false) ||
                 (optionDef.default === true && value === true)) {
                 return true;
@@ -69,9 +80,10 @@ class OptionsTracker {
         }
     }
 }
-exports.OptionsTracker = OptionsTracker;
 OptionsTracker.PASSWORD_DETECTION_STRING = "password";
 OptionsTracker.PRIVATE_REPLACE_VALUE = "private";
 OptionsTracker.PATH_REPLACE_VALUE = "_localpath";
 OptionsTracker.SIZE_EXEEDED_REPLACE_VALUE = "sizeExceeded";
+exports.OptionsTracker = OptionsTracker;
 yok_1.injector.register("optionsTracker", OptionsTracker);
+//# sourceMappingURL=options-track-helper.js.map

package/lib/helpers/package-path-helper.js

@@ -4,3 +4,4 @@ exports.resolvePackageJSONPath = exports.resolvePackagePath = void 0;
 const resolve_package_path_1 = require("@rigor789/resolve-package-path");
 Object.defineProperty(exports, "resolvePackagePath", { enumerable: true, get: function () { return resolve_package_path_1.resolvePackagePath; } });
 Object.defineProperty(exports, "resolvePackageJSONPath", { enumerable: true, get: function () { return resolve_package_path_1.resolvePackageJSONPath; } });
+//# sourceMappingURL=package-path-helper.js.map

package/lib/helpers/platform-command-helper.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.PlatformCommandHelper = void 0;
 const path = require("path");
@@ -22,79 +31,91 @@ class PlatformCommandHelper {
         this.$projectDataService = $projectDataService;
         this.$tempService = $tempService;
     }
-    async addPlatforms(platforms, projectData, frameworkPath) {
-        if (this.$options.hostProjectPath) {
-            this.$logger.info("Ignoring platform add becuase of --hostProjectPath flag");
-            return;
-        }
-        const platformsDir = projectData.platformsDir;
-        this.$fs.ensureDirectoryExists(platformsDir);
-        for (const platform of platforms) {
-            this.$platformValidationService.validatePlatform(platform, projectData);
-            const platformPath = path.join(projectData.platformsDir, platform);
-            const isPlatformAdded = this.isPlatformAdded(platform, platformPath, projectData);
-            if (isPlatformAdded) {
-                this.$errors.fail(`Platform ${platform} already added`);
+    addPlatforms(platforms, projectData, frameworkPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$options.hostProjectPath) {
+                this.$logger.info("Ignoring platform add becuase of --hostProjectPath flag");
+                return;
             }
-            await this.$platformController.addPlatform({
-                projectDir: projectData.projectDir,
-                platform,
-                frameworkPath,
-            });
-        }
-    }
-    async cleanPlatforms(platforms, projectData, framworkPath) {
-        for (const platform of platforms) {
-            const version = this.getCurrentPlatformVersion(platform, projectData);
-            await this.removePlatforms([platform], projectData);
-            const platformParam = version ? `${platform}@${version}` : platform;
-            await this.addPlatforms([platformParam], projectData, framworkPath);
-        }
-    }
-    async removePlatforms(platforms, projectData) {
-        if (this.$options.hostProjectPath) {
-            this.$logger.info("Ignoring platform remove becuase of --native-host flag");
-            return;
-        }
-        for (const platform of platforms) {
-            this.$platformValidationService.validatePlatformInstalled(platform, projectData);
-            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
-            let errorMessage;
-            try {
-                await platformData.platformProjectService.stopServices(platformData.projectRoot);
+            const platformsDir = projectData.platformsDir;
+            this.$fs.ensureDirectoryExists(platformsDir);
+            for (const platform of platforms) {
+                this.$platformValidationService.validatePlatform(platform, projectData);
+                const platformPath = path.join(projectData.platformsDir, platform);
+                const isPlatformAdded = this.isPlatformAdded(platform, platformPath, projectData);
+                if (isPlatformAdded) {
+                    this.$errors.fail(`Platform ${platform} already added`);
+                }
+                yield this.$platformController.addPlatform({
+                    projectDir: projectData.projectDir,
+                    platform,
+                    frameworkPath,
+                });
             }
-            catch (err) {
-                errorMessage = err.message;
+        });
+    }
+    cleanPlatforms(platforms, projectData, framworkPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const platform of platforms) {
+                const version = this.getCurrentPlatformVersion(platform, projectData);
+                yield this.removePlatforms([platform], projectData);
+                const platformParam = version ? `${platform}@${version}` : platform;
+                yield this.addPlatforms([platformParam], projectData, framworkPath);
             }
-            try {
-                const platformDir = path.join(projectData.platformsDir, platform.toLowerCase());
-                this.$fs.deleteDirectory(platformDir);
-                await this.$packageInstallationManager.uninstall(platformData.frameworkPackageName, projectData.projectDir);
-                this.$logger.info(`Platform ${platform} successfully removed.`);
+        });
+    }
+    removePlatforms(platforms, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$options.hostProjectPath) {
+                this.$logger.info("Ignoring platform remove becuase of --native-host flag");
+                return;
             }
-            catch (err) {
-                this.$logger.error(`Failed to remove ${platform} platform with errors:`);
-                if (errorMessage) {
-                    this.$logger.error(errorMessage);
+            for (const platform of platforms) {
+                this.$platformValidationService.validatePlatformInstalled(platform, projectData);
+                const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+                let errorMessage;
+                try {
+                    yield platformData.platformProjectService.stopServices(platformData.projectRoot);
+                }
+                catch (err) {
+                    errorMessage = err.message;
+                }
+                try {
+                    const platformDir = path.join(projectData.platformsDir, platform.toLowerCase());
+                    this.$fs.deleteDirectory(platformDir);
+                    yield this.$packageInstallationManager.uninstall(platformData.frameworkPackageName, projectData.projectDir);
+                    // this.$projectDataService.removeNSProperty(
+                    // 	projectData.projectDir,
+                    // 	platformData.frameworkPackageName
+                    // );
+                    this.$logger.info(`Platform ${platform} successfully removed.`);
+                }
+                catch (err) {
+                    this.$logger.error(`Failed to remove ${platform} platform with errors:`);
+                    if (errorMessage) {
+                        this.$logger.error(errorMessage);
+                    }
+                    this.$errors.fail(err.message);
                 }
-                this.$errors.fail(err.message);
             }
-        }
+        });
     }
-    async updatePlatforms(platforms, projectData) {
-        for (const platformParam of platforms) {
-            const data = platformParam.split("@"), platform = data[0], version = data[1];
-            const hasPlatformDirectory = this.$fs.exists(path.join(projectData.platformsDir, platform.toLowerCase()));
-            if (hasPlatformDirectory) {
-                await this.updatePlatform(platform, version, projectData);
-            }
-            else {
-                await this.$platformController.addPlatform({
-                    projectDir: projectData.projectDir,
-                    platform: platformParam,
-                });
+    updatePlatforms(platforms, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const platformParam of platforms) {
+                const data = platformParam.split("@"), platform = data[0], version = data[1];
+                const hasPlatformDirectory = this.$fs.exists(path.join(projectData.platformsDir, platform.toLowerCase()));
+                if (hasPlatformDirectory) {
+                    yield this.updatePlatform(platform, version, projectData);
+                }
+                else {
+                    yield this.$platformController.addPlatform({
+                        projectDir: projectData.projectDir,
+                        platform: platformParam,
+                    });
+                }
             }
-        }
+        });
     }
     getInstalledPlatforms(projectData) {
         if (!this.$fs.exists(projectData.platformsDir)) {
@@ -108,7 +129,7 @@ class PlatformCommandHelper {
         const installedPlatforms = this.getInstalledPlatforms(projectData);
         return _.filter(this.$mobileHelper.platformNames, (p) => {
             return (installedPlatforms.indexOf(p) < 0 &&
-                this.$platformValidationService.isPlatformSupportedForOS(p, projectData));
+                this.$platformValidationService.isPlatformSupportedForOS(p, projectData)); // Only those not already installed
         });
     }
     getPreparedPlatforms(projectData) {
@@ -132,44 +153,48 @@ class PlatformCommandHelper {
             return true;
         }
         return (prepareInfo.nativePlatformStatus !==
-            "1");
+            "1" /* constants.NativePlatformStatus.requiresPlatformAdd */);
     }
-    async updatePlatform(platform, version, projectData) {
-        const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
-        const data = this.$projectDataService.getRuntimePackage(projectData.projectDir, platformData.platformNameLowerCase);
-        const currentVersion = data && data.version ? data.version : "0.2.0";
-        const installedModuleDir = await this.$tempService.mkdirSync("runtime-to-update");
-        let newVersion = version === constants.PackageVersion.NEXT
-            ? await this.$packageInstallationManager.getNextVersion(platformData.frameworkPackageName)
-            : version ||
-                (await this.$packageInstallationManager.getLatestCompatibleVersion(platformData.frameworkPackageName));
-        await this.$pacoteService.extractPackage(`${platformData.frameworkPackageName}@${newVersion}`, installedModuleDir);
-        const cachedPackageData = this.$fs.readJson(path.join(installedModuleDir, "package.json"));
-        newVersion = (cachedPackageData && cachedPackageData.version) || newVersion;
-        if (!semver.valid(newVersion)) {
-            this.$errors.fail("The version %s is not valid. The version should consists from 3 parts separated by dot.", newVersion);
-        }
-        if (!semver.gt(currentVersion, newVersion)) {
-            await this.updatePlatformCore(platformData, { currentVersion, newVersion }, projectData);
-        }
-        else if (semver.eq(currentVersion, newVersion)) {
-            this.$errors.fail("Current and new version are the same.");
-        }
-        else {
-            this.$errors.fail(`Your current version: ${currentVersion} is higher than the one you're trying to install ${newVersion}.`);
-        }
+    updatePlatform(platform, version, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+            const data = this.$projectDataService.getRuntimePackage(projectData.projectDir, platformData.platformNameLowerCase);
+            const currentVersion = data && data.version ? data.version : "0.2.0";
+            const installedModuleDir = yield this.$tempService.mkdirSync("runtime-to-update");
+            let newVersion = version === constants.PackageVersion.NEXT
+                ? yield this.$packageInstallationManager.getNextVersion(platformData.frameworkPackageName)
+                : version ||
+                    (yield this.$packageInstallationManager.getLatestCompatibleVersion(platformData.frameworkPackageName));
+            yield this.$pacoteService.extractPackage(`${platformData.frameworkPackageName}@${newVersion}`, installedModuleDir);
+            const cachedPackageData = this.$fs.readJson(path.join(installedModuleDir, "package.json"));
+            newVersion = (cachedPackageData && cachedPackageData.version) || newVersion;
+            if (!semver.valid(newVersion)) {
+                this.$errors.fail("The version %s is not valid. The version should consists from 3 parts separated by dot.", newVersion);
+            }
+            if (!semver.gt(currentVersion, newVersion)) {
+                yield this.updatePlatformCore(platformData, { currentVersion, newVersion }, projectData);
+            }
+            else if (semver.eq(currentVersion, newVersion)) {
+                this.$errors.fail("Current and new version are the same.");
+            }
+            else {
+                this.$errors.fail(`Your current version: ${currentVersion} is higher than the one you're trying to install ${newVersion}.`);
+            }
+        });
     }
-    async updatePlatformCore(platformData, updateOptions, projectData) {
-        let packageName = platformData.normalizedPlatformName.toLowerCase();
-        await this.removePlatforms([packageName], projectData);
-        packageName = updateOptions.newVersion
-            ? `${packageName}@${updateOptions.newVersion}`
-            : packageName;
-        await this.$platformController.addPlatform({
-            projectDir: projectData.projectDir,
-            platform: packageName,
+    updatePlatformCore(platformData, updateOptions, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let packageName = platformData.normalizedPlatformName.toLowerCase();
+            yield this.removePlatforms([packageName], projectData);
+            packageName = updateOptions.newVersion
+                ? `${packageName}@${updateOptions.newVersion}`
+                : packageName;
+            yield this.$platformController.addPlatform({
+                projectDir: projectData.projectDir,
+                platform: packageName,
+            });
+            this.$logger.info("Successfully updated to version ", updateOptions.newVersion);
         });
-        this.$logger.info("Successfully updated to version ", updateOptions.newVersion);
     }
     isPlatformPrepared(platform, projectData) {
         const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
@@ -178,3 +203,4 @@ class PlatformCommandHelper {
 }
 exports.PlatformCommandHelper = PlatformCommandHelper;
 yok_1.injector.register("platformCommandHelper", PlatformCommandHelper);
+//# sourceMappingURL=platform-command-helper.js.map

package/lib/helpers/version-validator-helper.js

@@ -23,3 +23,4 @@ class VersionValidatorHelper {
     }
 }
 exports.VersionValidatorHelper = VersionValidatorHelper;
+//# sourceMappingURL=version-validator-helper.js.map

package/lib/key-commands/bootstrap.js

@@ -13,9 +13,10 @@ yok_1.injector.requireKeyCommand("R", path);
 yok_1.injector.requireKeyCommand("w", path);
 yok_1.injector.requireKeyCommand("c", path);
 yok_1.injector.requireKeyCommand("n", path);
-yok_1.injector.requireKeyCommand("?", path);
-yok_1.injector.requireKeyCommand("\u0003", path);
+yok_1.injector.requireKeyCommand("?" /* SpecialKeys.QuestionMark */, path);
+yok_1.injector.requireKeyCommand("\u0003" /* SpecialKeys.CtrlC */, path);
 yok_1.injector.requireCommand("open|ios", path);
 yok_1.injector.requireCommand("open|android", path);
 yok_1.injector.requireCommand("open|visionos", path);
 yok_1.injector.requireCommand("open|vision", path);
+//# sourceMappingURL=bootstrap.js.map