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

package/lib/device-sockets/ios/socket-request-executor.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.IOSSocketRequestExecutor = void 0;
 const constants = require("../../common/constants");
@@ -9,33 +18,42 @@ class IOSSocketRequestExecutor {
         this.$iOSNotification = $iOSNotification;
         this.$iOSNotificationService = $iOSNotificationService;
     }
-    async executeAttachRequest(device, timeout, appId) {
-        const deviceId = device.deviceInfo.identifier;
-        const mainRequestName = this.$iOSNotification.getAttachRequest(appId, deviceId);
-        const readyRequestName = this.$iOSNotification.getReadyForAttach(appId);
-        await this.executeRequest(mainRequestName, readyRequestName, appId, deviceId, timeout);
+    executeAttachRequest(device, timeout, appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceId = device.deviceInfo.identifier;
+            const mainRequestName = this.$iOSNotification.getAttachRequest(appId, deviceId);
+            const readyRequestName = this.$iOSNotification.getReadyForAttach(appId);
+            yield this.executeRequest(mainRequestName, readyRequestName, appId, deviceId, timeout);
+        });
     }
-    async executeRefreshRequest(device, timeout, appId) {
-        const deviceId = device.deviceInfo.identifier;
-        const mainRequestName = this.$iOSNotification.getRefreshRequest(appId);
-        const refreshRequestStartedName = this.$iOSNotification.getAppRefreshStarted(appId);
-        const result = await this.executeRequest(mainRequestName, refreshRequestStartedName, appId, deviceId, timeout);
-        return result;
+    executeRefreshRequest(device, timeout, appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceId = device.deviceInfo.identifier;
+            const mainRequestName = this.$iOSNotification.getRefreshRequest(appId);
+            const refreshRequestStartedName = this.$iOSNotification.getAppRefreshStarted(appId);
+            const result = yield this.executeRequest(mainRequestName, refreshRequestStartedName, appId, deviceId, timeout);
+            return result;
+        });
     }
-    async executeRequest(mainRequestName, successfulyExecutedNotificationName, appId, deviceId, timeout) {
-        let isSuccessful = false;
-        try {
-            const socket = await this.$iOSNotificationService.postNotification(deviceId, successfulyExecutedNotificationName, constants.IOS_OBSERVE_NOTIFICATION_COMMAND_TYPE);
-            const notificationPromise = this.$iOSNotificationService.awaitNotification(deviceId, +socket, timeout);
-            await this.$iOSNotificationService.postNotification(deviceId, mainRequestName);
-            await notificationPromise;
-            isSuccessful = true;
-        }
-        catch (e) {
-            this.$errors.fail(`The application ${appId} does not appear to be running on ${deviceId} or is not built with debugging enabled. Try starting the application manually.`);
-        }
-        return isSuccessful;
+    executeRequest(mainRequestName, successfulyExecutedNotificationName, appId, deviceId, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let isSuccessful = false;
+            try {
+                // We should create this promise here because we need to send the ObserveNotification on the device
+                // before we send the PostNotification.
+                const socket = yield this.$iOSNotificationService.postNotification(deviceId, successfulyExecutedNotificationName, constants.IOS_OBSERVE_NOTIFICATION_COMMAND_TYPE);
+                const notificationPromise = this.$iOSNotificationService.awaitNotification(deviceId, +socket, timeout);
+                yield this.$iOSNotificationService.postNotification(deviceId, mainRequestName);
+                yield notificationPromise;
+                isSuccessful = true;
+            }
+            catch (e) {
+                this.$errors.fail(`The application ${appId} does not appear to be running on ${deviceId} or is not built with debugging enabled. Try starting the application manually.`);
+            }
+            return isSuccessful;
+        });
     }
 }
 exports.IOSSocketRequestExecutor = IOSSocketRequestExecutor;
 yok_1.injector.register("iOSSocketRequestExecutor", IOSSocketRequestExecutor);
+//# sourceMappingURL=socket-request-executor.js.map

package/lib/helpers/android-bundle-validator-helper.js

@@ -22,7 +22,7 @@ class AndroidBundleValidatorHelper extends version_validator_helper_1.VersionVal
     }
     validateRuntimeVersion(projectData) {
         if (this.$options.aab) {
-            const runtimePackage = this.$projectDataService.getRuntimePackage(projectData.projectDir, "android");
+            const runtimePackage = this.$projectDataService.getRuntimePackage(projectData.projectDir, "android" /* PlatformTypes.android */);
             const androidRuntimeVersion = runtimePackage
                 ? runtimePackage.version
                 : "";
@@ -46,7 +46,8 @@ class AndroidBundleValidatorHelper extends version_validator_helper_1.VersionVal
         }
     }
 }
-exports.AndroidBundleValidatorHelper = AndroidBundleValidatorHelper;
 AndroidBundleValidatorHelper.MIN_RUNTIME_VERSION = "5.0.0";
 AndroidBundleValidatorHelper.MIN_ANDROID_WITH_AAB_SUPPORT = "4.4.0";
+exports.AndroidBundleValidatorHelper = AndroidBundleValidatorHelper;
 yok_1.injector.register("androidBundleValidatorHelper", AndroidBundleValidatorHelper);
+//# sourceMappingURL=android-bundle-validator-helper.js.map

package/lib/helpers/deploy-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.DeployCommandHelper = void 0;
 const yok_1 = require("../common/yok");
@@ -12,54 +21,51 @@ class DeployCommandHelper {
         this.$options = $options;
         this.$projectData = $projectData;
     }
-    async deploy(platform, additionalOptions) {
-        const emulator = this.$options.emulator;
-        await this.$devicesService.initialize({
-            deviceId: this.$options.device,
-            platform,
-            emulator,
-            skipInferPlatform: !platform,
-            sdk: this.$options.sdk,
-        });
-        const devices = this.$devicesService
-            .getDeviceInstances()
-            .filter((d) => !platform ||
-            d.deviceInfo.platform.toLowerCase() === platform.toLowerCase());
-        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,
-                skipWatcher: !this.$options.watch,
-                nativePrepare: {
+    deploy(platform, additionalOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emulator = this.$options.emulator;
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                platform,
+                emulator,
+                skipInferPlatform: !platform,
+                sdk: this.$options.sdk,
+            });
+            const devices = this.$devicesService
+                .getDeviceInstances()
+                .filter((d) => !platform ||
+                d.deviceInfo.platform.toLowerCase() === platform.toLowerCase());
+            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, skipWatcher: !this.$options.watch, nativePrepare: {
+                        skipNativePrepare: additionalOptions && additionalOptions.skipNativePrepare,
+                    } }));
+                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;
             });
-            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;
+            yield this.$deployController.deploy({ deviceDescriptors });
         });
-        await this.$deployController.deploy({ deviceDescriptors });
     }
 }
 exports.DeployCommandHelper = DeployCommandHelper;
 yok_1.injector.register("deployCommandHelper", DeployCommandHelper);
+//# sourceMappingURL=deploy-command-helper.js.map

package/lib/helpers/key-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 });
 const color_1 = require("../color");
 const yok_1 = require("../common/yok");
@@ -6,9 +15,10 @@ class KeyCommandHelper {
     constructor() {
         this.platform = "all";
         this.overrides = {};
-        this.onKeyPressed = async (data) => {
+        this.onKeyPressed = (data) => __awaiter(this, void 0, void 0, function* () {
             const key = data.toString();
-            if (this.keyCommandExecutionBlocked && key !== "\u0003")
+            // Allow Ctrl + C always.
+            if (this.keyCommandExecutionBlocked && key !== "\u0003" /* SpecialKeys.CtrlC */)
                 return;
             try {
                 const exists = yok_1.injector.getRegisteredKeyCommandsNames().includes(key);
@@ -25,13 +35,13 @@ class KeyCommandHelper {
                         if (keyCommand.willBlockKeyCommandExecution)
                             this.keyCommandExecutionBlocked = true;
                         if (this.overrides[key]) {
-                            if (!(await this.overrides[key]())) {
+                            if (!(yield this.overrides[key]())) {
                                 this.keyCommandExecutionBlocked = false;
                                 process.stdin.resume();
                                 return;
                             }
                         }
-                        if (keyCommand.key !== "\u0003") {
+                        if (keyCommand.key !== "\u0003" /* SpecialKeys.CtrlC */) {
                             const line = ` ${color_1.color.dim("→")} ${color_1.color.bold(keyCommand.key)} — ${keyCommand.description}`;
                             const lineLength = (0, color_1.stripColors)(line).length - 1;
                             console.log(color_1.color.dim(` ┌${"─".repeat(lineLength)}┐`));
@@ -39,7 +49,7 @@ class KeyCommandHelper {
                             console.log(color_1.color.dim(` └${"─".repeat(lineLength)}┘`));
                             console.log("");
                         }
-                        const result = await keyCommand.execute(this.platform);
+                        const result = yield keyCommand.execute(this.platform);
                         this.keyCommandExecutionBlocked = false;
                         if (process.stdin.setRawMode) {
                             process.stdin.resume();
@@ -53,7 +63,7 @@ class KeyCommandHelper {
                 const $logger = yok_1.injector.resolve("logger");
                 $logger.error(e.message);
             }
-        };
+        });
     }
     addOverride(key, execute) {
         this.overrides[key] = execute;
@@ -113,3 +123,4 @@ class KeyCommandHelper {
 }
 exports.default = KeyCommandHelper;
 yok_1.injector.register("keyCommandHelper", KeyCommandHelper);
+//# sourceMappingURL=key-command-helper.js.map

package/lib/helpers/livesync-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.LiveSyncCommandHelper = void 0;
 const _ = require("lodash");
@@ -25,6 +34,7 @@ class LiveSyncCommandHelper {
     get $platformsDataService() {
         return this.$injector.resolve("platformsDataService");
     }
+    // TODO: Remove this and replace it with buildData
     getLiveSyncData(projectDir) {
         const liveSyncInfo = {
             projectDir,
@@ -39,56 +49,54 @@ class LiveSyncCommandHelper {
         };
         return liveSyncInfo;
     }
-    async getDeviceInstances(platform) {
-        await this.$devicesService.initialize({
-            platform,
-            deviceId: this.$options.device,
-            emulator: this.$options.emulator,
-            skipInferPlatform: !platform,
-            sdk: this.$options.sdk,
+    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;
         });
-        const devices = this.$devicesService
-            .getDeviceInstances()
-            .filter((d) => !platform ||
-            d.deviceInfo.platform.toLowerCase() === platform.toLowerCase());
-        return devices;
     }
-    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,
+    createDeviceDescriptors(devices, platform, additionalOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Now let's take data for each device:
+            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;
             });
-            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;
         });
-        return deviceDescriptors;
     }
     getPlatformsForOperation(platform) {
         const availablePlatforms = platform
@@ -96,110 +104,120 @@ class LiveSyncCommandHelper {
             : _.values(this.$mobileHelper.platformNames.map((p) => p.toLowerCase()));
         return availablePlatforms;
     }
-    async executeCommandLiveSync(platform, additionalOptions) {
-        const devices = await this.getDeviceInstances(platform);
-        await this.executeLiveSyncOperation(devices, platform, additionalOptions);
+    executeCommandLiveSync(platform, additionalOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.getDeviceInstances(platform);
+            yield this.executeLiveSyncOperation(devices, platform, additionalOptions);
+        });
     }
-    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);
+    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,
+                });
             }
+            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 /* ErrorCodes.ALL_DEVICES_DISCONNECTED */);
+                }
+            }));
         });
     }
-    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;
-    }
-    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.");
+    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;
             }
-            else {
-                this.$errors.fail("Unable to find applicable devices to execute operation and unable to start emulator when platform is not specified.");
+            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.");
+                }
             }
-        }
-        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 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 };
+            const deviceDescriptors = yield this.createDeviceDescriptors(devices, platform, additionalOptions);
+            const liveSyncInfo = this.getLiveSyncData(this.$projectData.projectDir);
+            return { liveSyncInfo, deviceDescriptors };
+        });
     }
-    async runInRelease(platform, deviceDescriptors) {
-        await this.$devicesService.initialize({
-            platform,
-            deviceId: this.$options.device,
-            emulator: this.$options.emulator,
-            skipInferPlatform: !platform,
-            sdk: this.$options.sdk,
+    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,
+                });
+            }
         });
-        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,
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.getDeviceInstances();
+            return this.$runController.stop({
                 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,
-            },
         });
     }
 }
 exports.LiveSyncCommandHelper = LiveSyncCommandHelper;
 yok_1.injector.register("liveSyncCommandHelper", LiveSyncCommandHelper);
+//# sourceMappingURL=livesync-command-helper.js.map