@akylas/nativescript-cli 8.8.2 → 8.8.3

package/lib/helpers/livesync-command-helper.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.LiveSyncCommandHelper = void 0;
 const _ = require("lodash");
@@ -48,53 +39,56 @@ class LiveSyncCommandHelper {
         };
         return liveSyncInfo;
     }
-    getDeviceInstances(platform) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$devicesService.initialize({
-                platform,
-                deviceId: this.$options.device,
-                emulator: this.$options.emulator,
-                skipInferPlatform: !platform,
-                sdk: this.$options.sdk,
-            });
-            const devices = this.$devicesService
-                .getDeviceInstances()
-                .filter((d) => !platform ||
-                d.deviceInfo.platform.toLowerCase() === platform.toLowerCase());
-            return devices;
+    async getDeviceInstances(platform) {
+        await this.$devicesService.initialize({
+            platform,
+            deviceId: this.$options.device,
+            emulator: this.$options.emulator,
+            skipInferPlatform: !platform,
+            sdk: this.$options.sdk,
         });
+        const devices = this.$devicesService
+            .getDeviceInstances()
+            .filter((d) => !platform ||
+            d.deviceInfo.platform.toLowerCase() === platform.toLowerCase());
+        return devices;
     }
-    createDeviceDescriptors(devices, platform, additionalOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceDescriptors = devices.map((d) => {
-                const outputPath = additionalOptions &&
-                    additionalOptions.getOutputDirectory &&
-                    additionalOptions.getOutputDirectory({
-                        platform: d.deviceInfo.platform,
-                        emulator: d.isEmulator,
-                        projectDir: this.$projectData.projectDir,
-                    });
-                const buildData = this.$buildDataService.getBuildData(this.$projectData.projectDir, d.deviceInfo.platform, Object.assign(Object.assign({}, this.$options.argv), { outputPath, buildForDevice: !d.isEmulator, watch: !this.$options.release && this.$options.watch, nativePrepare: {
-                        forceRebuildNativeApp: additionalOptions.forceRebuildNativeApp,
-                    }, _device: d }));
-                this.$androidBundleValidatorHelper.validateDeviceApiLevel(d, buildData);
-                const buildAction = additionalOptions && additionalOptions.buildPlatform
-                    ? additionalOptions.buildPlatform.bind(additionalOptions.buildPlatform, d.deviceInfo.platform, buildData, this.$projectData)
-                    : this.$buildController.build.bind(this.$buildController, buildData);
-                const info = {
-                    identifier: d.deviceInfo.identifier,
-                    buildAction,
-                    debuggingEnabled: additionalOptions &&
-                        additionalOptions.deviceDebugMap &&
-                        additionalOptions.deviceDebugMap[d.deviceInfo.identifier],
-                    debugOptions: this.$options,
-                    skipNativePrepare: additionalOptions && additionalOptions.skipNativePrepare,
-                    buildData,
-                };
-                return info;
+    async createDeviceDescriptors(devices, platform, additionalOptions) {
+        const deviceDescriptors = devices.map((d) => {
+            const outputPath = additionalOptions &&
+                additionalOptions.getOutputDirectory &&
+                additionalOptions.getOutputDirectory({
+                    platform: d.deviceInfo.platform,
+                    emulator: d.isEmulator,
+                    projectDir: this.$projectData.projectDir,
+                });
+            const buildData = this.$buildDataService.getBuildData(this.$projectData.projectDir, d.deviceInfo.platform, {
+                ...this.$options.argv,
+                outputPath,
+                buildForDevice: !d.isEmulator,
+                watch: !this.$options.release && this.$options.watch,
+                nativePrepare: {
+                    forceRebuildNativeApp: additionalOptions.forceRebuildNativeApp,
+                },
+                _device: d,
             });
-            return deviceDescriptors;
+            this.$androidBundleValidatorHelper.validateDeviceApiLevel(d, buildData);
+            const buildAction = additionalOptions && additionalOptions.buildPlatform
+                ? additionalOptions.buildPlatform.bind(additionalOptions.buildPlatform, d.deviceInfo.platform, buildData, this.$projectData)
+                : this.$buildController.build.bind(this.$buildController, buildData);
+            const info = {
+                identifier: d.deviceInfo.identifier,
+                buildAction,
+                debuggingEnabled: additionalOptions &&
+                    additionalOptions.deviceDebugMap &&
+                    additionalOptions.deviceDebugMap[d.deviceInfo.identifier],
+                debugOptions: this.$options,
+                skipNativePrepare: additionalOptions && additionalOptions.skipNativePrepare,
+                buildData,
+            };
+            return info;
         });
+        return deviceDescriptors;
     }
     getPlatformsForOperation(platform) {
         const availablePlatforms = platform
@@ -102,117 +96,108 @@ class LiveSyncCommandHelper {
             : _.values(this.$mobileHelper.platformNames.map((p) => p.toLowerCase()));
         return availablePlatforms;
     }
-    executeCommandLiveSync(platform, additionalOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const devices = yield this.getDeviceInstances(platform);
-            yield this.executeLiveSyncOperation(devices, platform, additionalOptions);
-        });
+    async executeCommandLiveSync(platform, additionalOptions) {
+        const devices = await this.getDeviceInstances(platform);
+        await this.executeLiveSyncOperation(devices, platform, additionalOptions);
     }
-    executeLiveSyncOperation(devices, platform, additionalOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { liveSyncInfo, deviceDescriptors } = yield this.executeLiveSyncOperationCore(devices, platform, additionalOptions);
-            if (this.$options.release) {
-                yield this.runInRelease(platform, deviceDescriptors);
-                return;
-            }
-            if (additionalOptions.restartLiveSync) {
-                yield this.$runController.stop({
-                    projectDir: this.$projectData.projectDir,
-                    deviceIdentifiers: deviceDescriptors.map((device) => device.identifier),
-                    stopOptions: {
-                        shouldAwaitAllActions: true,
-                        keepProcessAlive: true,
-                    },
-                });
-                const devices = yield this.getDeviceInstances(platform);
-                yield this.executeLiveSyncOperation(devices, platform, Object.assign(Object.assign({}, additionalOptions), { restartLiveSync: false }));
-                return;
-            }
-            else {
-                yield this.$runController.run({
-                    liveSyncInfo,
-                    deviceDescriptors,
-                });
+    async executeLiveSyncOperation(devices, platform, additionalOptions) {
+        const { liveSyncInfo, deviceDescriptors } = await this.executeLiveSyncOperationCore(devices, platform, additionalOptions);
+        if (this.$options.release) {
+            await this.runInRelease(platform, deviceDescriptors);
+            return;
+        }
+        if (additionalOptions.restartLiveSync) {
+            await this.$runController.stop({
+                projectDir: this.$projectData.projectDir,
+                deviceIdentifiers: deviceDescriptors.map((device) => device.identifier),
+                stopOptions: {
+                    shouldAwaitAllActions: true,
+                    keepProcessAlive: true,
+                },
+            });
+            const devices = await this.getDeviceInstances(platform);
+            await this.executeLiveSyncOperation(devices, platform, {
+                ...additionalOptions,
+                restartLiveSync: false,
+            });
+            return;
+        }
+        else {
+            await this.$runController.run({
+                liveSyncInfo,
+                deviceDescriptors,
+            });
+        }
+        this.$runController.on(constants_1.RunOnDeviceEvents.runOnDeviceStopped, async (data) => {
+            const devices = await this.getDeviceInstances(platform);
+            const remainingDevicesToSync = devices.map((d) => d.deviceInfo.identifier);
+            _.remove(remainingDevicesToSync, (d) => d === data.deviceIdentifier);
+            if (remainingDevicesToSync.length === 0 && !data.keepProcessAlive) {
+                process.exit(134);
             }
-            this.$runController.on(constants_1.RunOnDeviceEvents.runOnDeviceStopped, (data) => __awaiter(this, void 0, void 0, function* () {
-                const devices = yield this.getDeviceInstances(platform);
-                const remainingDevicesToSync = devices.map((d) => d.deviceInfo.identifier);
-                _.remove(remainingDevicesToSync, (d) => d === data.deviceIdentifier);
-                if (remainingDevicesToSync.length === 0 && !data.keepProcessAlive) {
-                    process.exit(134);
-                }
-            }));
         });
     }
-    validatePlatform(platform) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = {};
-            const availablePlatforms = this.getPlatformsForOperation(platform);
-            for (const availablePlatform of availablePlatforms) {
-                const platformData = this.$platformsDataService.getPlatformData(availablePlatform, this.$projectData);
-                const platformProjectService = platformData.platformProjectService;
-                const validateOutput = yield platformProjectService.validate(this.$projectData, this.$options);
-                result[availablePlatform.toLowerCase()] = validateOutput;
-            }
-            return result;
-        });
+    async validatePlatform(platform) {
+        const result = {};
+        const availablePlatforms = this.getPlatformsForOperation(platform);
+        for (const availablePlatform of availablePlatforms) {
+            const platformData = this.$platformsDataService.getPlatformData(availablePlatform, this.$projectData);
+            const platformProjectService = platformData.platformProjectService;
+            const validateOutput = await platformProjectService.validate(this.$projectData, this.$options);
+            result[availablePlatform.toLowerCase()] = validateOutput;
+        }
+        return result;
     }
-    executeLiveSyncOperationCore(devices, platform, additionalOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!devices || !devices.length) {
-                if (platform) {
-                    this.$errors.fail("Unable to find applicable devices to execute operation. Ensure connected devices are trusted and try again.");
-                }
-                else {
-                    this.$errors.fail("Unable to find applicable devices to execute operation and unable to start emulator when platform is not specified.");
-                }
+    async executeLiveSyncOperationCore(devices, platform, additionalOptions) {
+        if (!devices || !devices.length) {
+            if (platform) {
+                this.$errors.fail("Unable to find applicable devices to execute operation. Ensure connected devices are trusted and try again.");
             }
-            const workingWithAppleDevices = !platform || this.$mobileHelper.isApplePlatform(platform);
-            const shouldKeepProcessAlive = this.$options.watch || !this.$options.justlaunch;
-            if (shouldKeepProcessAlive) {
-                this.$analyticsService.setShouldDispose(false);
-                this.$cleanupService.setShouldDispose(false);
-                if (workingWithAppleDevices) {
-                    this.$iosDeviceOperations.setShouldDispose(false);
-                    this.$iOSSimulatorLogProvider.setShouldDispose(false);
-                }
+            else {
+                this.$errors.fail("Unable to find applicable devices to execute operation and unable to start emulator when platform is not specified.");
             }
-            const deviceDescriptors = yield this.createDeviceDescriptors(devices, platform, additionalOptions);
-            const liveSyncInfo = this.getLiveSyncData(this.$projectData.projectDir);
-            return { liveSyncInfo, deviceDescriptors };
-        });
-    }
-    runInRelease(platform, deviceDescriptors) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$devicesService.initialize({
-                platform,
-                deviceId: this.$options.device,
-                emulator: this.$options.emulator,
-                skipInferPlatform: !platform,
-                sdk: this.$options.sdk,
-            });
-            yield this.$deployController.deploy({ deviceDescriptors });
-            for (const deviceDescriptor of deviceDescriptors) {
-                const device = this.$devicesService.getDeviceByIdentifier(deviceDescriptor.identifier);
-                yield device.applicationManager.startApplication({
-                    appId: this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()],
-                    projectName: this.$projectData.projectName,
-                    projectDir: this.$projectData.projectDir,
-                });
+        }
+        const workingWithAppleDevices = !platform || this.$mobileHelper.isApplePlatform(platform);
+        const shouldKeepProcessAlive = this.$options.watch || !this.$options.justlaunch;
+        if (shouldKeepProcessAlive) {
+            this.$analyticsService.setShouldDispose(false);
+            this.$cleanupService.setShouldDispose(false);
+            if (workingWithAppleDevices) {
+                this.$iosDeviceOperations.setShouldDispose(false);
+                this.$iOSSimulatorLogProvider.setShouldDispose(false);
             }
-        });
+        }
+        const deviceDescriptors = await this.createDeviceDescriptors(devices, platform, additionalOptions);
+        const liveSyncInfo = this.getLiveSyncData(this.$projectData.projectDir);
+        return { liveSyncInfo, deviceDescriptors };
     }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const devices = yield this.getDeviceInstances();
-            return this.$runController.stop({
+    async runInRelease(platform, deviceDescriptors) {
+        await this.$devicesService.initialize({
+            platform,
+            deviceId: this.$options.device,
+            emulator: this.$options.emulator,
+            skipInferPlatform: !platform,
+            sdk: this.$options.sdk,
+        });
+        await this.$deployController.deploy({ deviceDescriptors });
+        for (const deviceDescriptor of deviceDescriptors) {
+            const device = this.$devicesService.getDeviceByIdentifier(deviceDescriptor.identifier);
+            await device.applicationManager.startApplication({
+                appId: this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()],
+                projectName: this.$projectData.projectName,
                 projectDir: this.$projectData.projectDir,
-                deviceIdentifiers: devices.map((d) => d.deviceInfo.identifier),
-                stopOptions: {
-                    shouldAwaitAllActions: true,
-                    keepProcessAlive: true,
-                },
             });
+        }
+    }
+    async stop() {
+        const devices = await this.getDeviceInstances();
+        return this.$runController.stop({
+            projectDir: this.$projectData.projectDir,
+            deviceIdentifiers: devices.map((d) => d.deviceInfo.identifier),
+            stopOptions: {
+                shouldAwaitAllActions: true,
+                keepProcessAlive: true,
+            },
         });
     }
 }

package/lib/helpers/network-connectivity-validator.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.NetworkConnectivityValidator = void 0;
 const dns = require("dns");
@@ -17,13 +8,11 @@ class NetworkConnectivityValidator {
         this.$errors = $errors;
         this.$logger = $logger;
     }
-    validate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isConnected = yield this.isConnected();
-            if (!isConnected) {
-                this.$errors.fail(NetworkConnectivityValidator.NO_INTERNET_ERROR_MESSAGE);
-            }
-        });
+    async validate() {
+        const isConnected = await this.isConnected();
+        if (!isConnected) {
+            this.$errors.fail(NetworkConnectivityValidator.NO_INTERNET_ERROR_MESSAGE);
+        }
     }
     isConnected() {
         return new Promise((resolve, reject) => {
@@ -40,8 +29,8 @@ 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);

package/lib/helpers/options-track-helper.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.OptionsTracker = void 0;
 const path = require("path");
@@ -17,13 +8,11 @@ class OptionsTracker {
     constructor($analyticsService) {
         this.$analyticsService = $analyticsService;
     }
-    trackOptions(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const trackObject = this.getTrackObject(options);
-            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
-                action: "Options",
-                additionalData: JSON.stringify(trackObject),
-            });
+    async trackOptions(options) {
+        const trackObject = this.getTrackObject(options);
+        await this.$analyticsService.trackEventActionInGoogleAnalytics({
+            action: "Options",
+            additionalData: JSON.stringify(trackObject),
         });
     }
     getTrackObject(options) {
@@ -80,9 +69,9 @@ 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);