nativescript 8.9.0-alpha.2 → 8.9.0-dev.0

package/lib/common/command-params.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.StringParameterBuilder = exports.StringCommandParameter = void 0;
 const yok_1 = require("./yok");
@@ -16,16 +7,14 @@ class StringCommandParameter {
         this.$injector = $injector;
         this.mandatory = false;
     }
-    validate(validationValue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!validationValue) {
-                if (this.errorMessage) {
-                    this.$injector.resolve("errors").fail(this.errorMessage);
-                }
-                return false;
+    async validate(validationValue) {
+        if (!validationValue) {
+            if (this.errorMessage) {
+                this.$injector.resolve("errors").fail(this.errorMessage);
             }
-            return true;
-        });
+            return false;
+        }
+        return true;
     }
 }
 exports.StringCommandParameter = StringCommandParameter;

package/lib/common/commands/analytics.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.ErrorReportingCommand = exports.UsageReportingCommand = exports.AnalyticsCommandParameter = void 0;
 const yok_1 = require("../yok");
@@ -16,19 +7,17 @@ class AnalyticsCommandParameter {
         this.$errors = $errors;
         this.mandatory = false;
     }
-    validate(validationValue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const val = validationValue || "";
-            switch (val.toLowerCase()) {
-                case "enable":
-                case "disable":
-                case "status":
-                case "":
-                    return true;
-                default:
-                    this.$errors.failWithHelp(`The value '${validationValue}' is not valid. Valid values are 'enable', 'disable' and 'status'.`);
-            }
-        });
+    async validate(validationValue) {
+        const val = validationValue || "";
+        switch (val.toLowerCase()) {
+            case "enable":
+            case "disable":
+            case "status":
+            case "":
+                return true;
+            default:
+                this.$errors.failWithHelp(`The value '${validationValue}' is not valid. Valid values are 'enable', 'disable' and 'status'.`);
+        }
     }
 }
 exports.AnalyticsCommandParameter = AnalyticsCommandParameter;
@@ -43,24 +32,22 @@ class AnalyticsCommand {
         this.allowedParameters = [new AnalyticsCommandParameter(this.$errors)];
         this.disableAnalytics = true;
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const arg = args[0] || "";
-            switch (arg.toLowerCase()) {
-                case "enable":
-                    yield this.$analyticsService.setStatus(this.settingName, true);
-                    this.$logger.info(`${this.humanReadableSettingName} is now enabled.`);
-                    break;
-                case "disable":
-                    yield this.$analyticsService.setStatus(this.settingName, false);
-                    this.$logger.info(`${this.humanReadableSettingName} is now disabled.`);
-                    break;
-                case "status":
-                case "":
-                    this.$logger.info(yield this.$analyticsService.getStatusMessage(this.settingName, this.$options.json, this.humanReadableSettingName));
-                    break;
-            }
-        });
+    async execute(args) {
+        const arg = args[0] || "";
+        switch (arg.toLowerCase()) {
+            case "enable":
+                await this.$analyticsService.setStatus(this.settingName, true);
+                this.$logger.info(`${this.humanReadableSettingName} is now enabled.`);
+                break;
+            case "disable":
+                await this.$analyticsService.setStatus(this.settingName, false);
+                this.$logger.info(`${this.humanReadableSettingName} is now disabled.`);
+                break;
+            case "status":
+            case "":
+                this.$logger.info(await this.$analyticsService.getStatusMessage(this.settingName, this.$options.json, this.humanReadableSettingName));
+                break;
+        }
     }
 }
 class UsageReportingCommand extends AnalyticsCommand {

package/lib/common/commands/autocompletion.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.AutoCompleteStatusCommand = exports.EnableAutoCompleteCommand = exports.DisableAutoCompleteCommand = exports.AutoCompleteCommand = void 0;
 const helpers = require("../helpers");
@@ -20,30 +11,28 @@ class AutoCompleteCommand {
         this.disableAnalytics = true;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (helpers.isInteractive()) {
-                if (this.$autoCompletionService.isAutoCompletionEnabled()) {
-                    if (this.$autoCompletionService.isObsoleteAutoCompletionEnabled()) {
-                        yield this.$autoCompletionService.enableAutoCompletion();
-                    }
-                    else {
-                        this.$logger.info("Autocompletion is already enabled");
-                    }
+    async execute(args) {
+        if (helpers.isInteractive()) {
+            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                if (this.$autoCompletionService.isObsoleteAutoCompletionEnabled()) {
+                    await this.$autoCompletionService.enableAutoCompletion();
                 }
                 else {
-                    this.$logger.info("If you are using bash or zsh, you can enable command-line completion.");
-                    const message = "Do you want to enable it now?";
-                    const autoCompetionStatus = yield this.$prompter.confirm(message, () => true);
-                    if (autoCompetionStatus) {
-                        yield this.$autoCompletionService.enableAutoCompletion();
-                    }
-                    else {
-                        this.$autoCompletionService.disableAutoCompletion();
-                    }
+                    this.$logger.info("Autocompletion is already enabled");
                 }
             }
-        });
+            else {
+                this.$logger.info("If you are using bash or zsh, you can enable command-line completion.");
+                const message = "Do you want to enable it now?";
+                const autoCompetionStatus = await this.$prompter.confirm(message, () => true);
+                if (autoCompetionStatus) {
+                    await this.$autoCompletionService.enableAutoCompletion();
+                }
+                else {
+                    this.$autoCompletionService.disableAutoCompletion();
+                }
+            }
+        }
     }
 }
 exports.AutoCompleteCommand = AutoCompleteCommand;
@@ -55,15 +44,13 @@ class DisableAutoCompleteCommand {
         this.disableAnalytics = true;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
-                this.$autoCompletionService.disableAutoCompletion();
-            }
-            else {
-                this.$logger.info("Autocompletion is already disabled.");
-            }
-        });
+    async execute(args) {
+        if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+            this.$autoCompletionService.disableAutoCompletion();
+        }
+        else {
+            this.$logger.info("Autocompletion is already disabled.");
+        }
     }
 }
 exports.DisableAutoCompleteCommand = DisableAutoCompleteCommand;
@@ -75,15 +62,13 @@ class EnableAutoCompleteCommand {
         this.disableAnalytics = true;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
-                this.$logger.info("Autocompletion is already enabled.");
-            }
-            else {
-                yield this.$autoCompletionService.enableAutoCompletion();
-            }
-        });
+    async execute(args) {
+        if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+            this.$logger.info("Autocompletion is already enabled.");
+        }
+        else {
+            await this.$autoCompletionService.enableAutoCompletion();
+        }
     }
 }
 exports.EnableAutoCompleteCommand = EnableAutoCompleteCommand;
@@ -95,15 +80,13 @@ class AutoCompleteStatusCommand {
         this.disableAnalytics = true;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
-                this.$logger.info("Autocompletion is enabled.");
-            }
-            else {
-                this.$logger.info("Autocompletion is disabled.");
-            }
-        });
+    async execute(args) {
+        if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+            this.$logger.info("Autocompletion is enabled.");
+        }
+        else {
+            this.$logger.info("Autocompletion is disabled.");
+        }
     }
 }
 exports.AutoCompleteStatusCommand = AutoCompleteStatusCommand;

package/lib/common/commands/device/device-log-stream.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.OpenDeviceLogStreamCommand = void 0;
 const yok_1 = require("../../yok");
@@ -23,22 +14,20 @@ class OpenDeviceLogStreamCommand {
         $iOSSimulatorLogProvider.setShouldDispose(false);
         $cleanupService.setShouldDispose(false);
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$deviceLogProvider.setLogLevel(this.$loggingLevels.full);
-            yield this.$devicesService.initialize({
-                deviceId: this.$options.device,
-                skipInferPlatform: true,
-            });
-            if (this.$devicesService.deviceCount > 1) {
-                yield this.$commandsService.tryExecuteCommand("device", []);
-                this.$errors.failWithHelp(OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE);
-            }
-            const action = (device) => device.openDeviceLogStream();
-            yield this.$devicesService.execute(action);
+    async execute(args) {
+        this.$deviceLogProvider.setLogLevel(this.$loggingLevels.full);
+        await this.$devicesService.initialize({
+            deviceId: this.$options.device,
+            skipInferPlatform: true,
         });
+        if (this.$devicesService.deviceCount > 1) {
+            await this.$commandsService.tryExecuteCommand("device", []);
+            this.$errors.failWithHelp(OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE);
+        }
+        const action = (device) => device.openDeviceLogStream();
+        await this.$devicesService.execute(action);
     }
 }
-OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE = "More than one device found. Specify device explicitly.";
 exports.OpenDeviceLogStreamCommand = OpenDeviceLogStreamCommand;
+OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE = "More than one device found. Specify device explicitly.";
 yok_1.injector.registerCommand(["device|log", "devices|log"], OpenDeviceLogStreamCommand);

package/lib/common/commands/device/get-file.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.GetFileCommand = void 0;
 const yok_1 = require("../../yok");
@@ -23,31 +14,29 @@ class GetFileCommand {
             this.$stringParameter,
         ];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$devicesService.initialize({
-                deviceId: this.$options.device,
-                skipInferPlatform: true,
-            });
-            let appIdentifier = args[1];
-            if (!appIdentifier) {
-                try {
-                    this.$projectData.initializeProjectData();
-                }
-                catch (err) {
-                }
-                if (!this.$projectData.projectIdentifiers) {
-                    this.$errors.fail("Please enter application identifier or execute this command in project.");
-                }
-            }
-            const action = (device) => __awaiter(this, void 0, void 0, function* () {
-                appIdentifier =
-                    appIdentifier ||
-                        this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()];
-                yield device.fileSystem.getFile(args[0], appIdentifier, this.$options.file);
-            });
-            yield this.$devicesService.execute(action);
+    async execute(args) {
+        await this.$devicesService.initialize({
+            deviceId: this.$options.device,
+            skipInferPlatform: true,
         });
+        let appIdentifier = args[1];
+        if (!appIdentifier) {
+            try {
+                this.$projectData.initializeProjectData();
+            }
+            catch (err) {
+            }
+            if (!this.$projectData.projectIdentifiers) {
+                this.$errors.fail("Please enter application identifier or execute this command in project.");
+            }
+        }
+        const action = async (device) => {
+            appIdentifier =
+                appIdentifier ||
+                    this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()];
+            await device.fileSystem.getFile(args[0], appIdentifier, this.$options.file);
+        };
+        await this.$devicesService.execute(action);
     }
 }
 exports.GetFileCommand = GetFileCommand;

package/lib/common/commands/device/list-applications.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.ListApplicationsCommand = void 0;
 const os_1 = require("os");
@@ -21,21 +12,19 @@ class ListApplicationsCommand {
         this.$options = $options;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$devicesService.initialize({
-                deviceId: this.$options.device,
-                skipInferPlatform: true,
-            });
-            const output = [];
-            const action = (device) => __awaiter(this, void 0, void 0, function* () {
-                const applications = yield device.applicationManager.getInstalledApplications();
-                output.push(util.format("%s=====Installed applications on device with UDID '%s' are:", os_1.EOL, device.deviceInfo.identifier));
-                _.each(applications, (applicationId) => output.push(applicationId));
-            });
-            yield this.$devicesService.execute(action);
-            this.$logger.info(output.join(os_1.EOL));
+    async execute(args) {
+        await this.$devicesService.initialize({
+            deviceId: this.$options.device,
+            skipInferPlatform: true,
         });
+        const output = [];
+        const action = async (device) => {
+            const applications = await device.applicationManager.getInstalledApplications();
+            output.push(util.format("%s=====Installed applications on device with UDID '%s' are:", os_1.EOL, device.deviceInfo.identifier));
+            _.each(applications, (applicationId) => output.push(applicationId));
+        };
+        await this.$devicesService.execute(action);
+        this.$logger.info(output.join(os_1.EOL));
     }
 }
 exports.ListApplicationsCommand = ListApplicationsCommand;

package/lib/common/commands/device/list-devices.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.ListDevicesCommand = void 0;
 const helpers_1 = require("../../helpers");
@@ -25,76 +16,74 @@ class ListDevicesCommand {
         this.$options = $options;
         this.allowedParameters = [this.$stringParameter];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const devices = {
-                devices: [],
-            };
-            if (this.$options.availableDevices) {
-                const platform = this.$mobileHelper.normalizePlatformName(args[0]);
-                if (!platform && args[0]) {
-                    this.$errors.fail(`${args[0]} is not a valid device platform. The valid platforms are ${(0, helpers_1.formatListOfNames)(this.$mobileHelper.platformNames)}`);
-                }
-                const availableEmulatorsOutput = yield this.$devicesService.getEmulatorImages({ platform });
-                const emulators = this.$emulatorHelper.getEmulatorsFromAvailableEmulatorsOutput(availableEmulatorsOutput);
-                devices.available = emulators;
-                if (!this.$options.json) {
-                    this.$logger.info(color_1.color.bold("\n Available emulators"));
-                    this.printEmulators(emulators);
-                }
+    async execute(args) {
+        const devices = {
+            devices: [],
+        };
+        if (this.$options.availableDevices) {
+            const platform = this.$mobileHelper.normalizePlatformName(args[0]);
+            if (!platform && args[0]) {
+                this.$errors.fail(`${args[0]} is not a valid device platform. The valid platforms are ${(0, helpers_1.formatListOfNames)(this.$mobileHelper.platformNames)}`);
             }
-            let index = 1;
-            yield this.$devicesService.initialize({
-                platform: args[0],
-                deviceId: null,
-                skipInferPlatform: true,
-                skipDeviceDetectionInterval: true,
-                skipEmulatorStart: true,
-                fullDiscovery: true,
-            });
+            const availableEmulatorsOutput = await this.$devicesService.getEmulatorImages({ platform });
+            const emulators = this.$emulatorHelper.getEmulatorsFromAvailableEmulatorsOutput(availableEmulatorsOutput);
+            devices.available = emulators;
             if (!this.$options.json) {
-                this.$logger.info(color_1.color.bold("\n Connected devices & emulators"));
-            }
-            const table = (0, helpers_1.createTable)([
-                "#",
-                "Device Name",
-                "Platform",
-                "Device Identifier",
-                "Type",
-                "Status",
-                "Connection Type",
-            ], []);
-            let action;
-            if (this.$options.json) {
-                action = (device) => __awaiter(this, void 0, void 0, function* () {
-                    devices.devices.push(device.deviceInfo);
-                });
-            }
-            else {
-                action = (device) => __awaiter(this, void 0, void 0, function* () {
-                    table.push([
-                        (index++).toString(),
-                        device.deviceInfo.displayName || "",
-                        device.deviceInfo.platform || "",
-                        device.deviceInfo.identifier || "",
-                        device.deviceInfo.type || "",
-                        device.deviceInfo.status || "",
-                        device.deviceInfo.connectionTypes
-                            .map((type) => constants_1.DeviceConnectionType[type])
-                            .join(", "),
-                    ]);
-                });
-            }
-            yield this.$devicesService.execute(action, undefined, {
-                allowNoDevices: true,
-            });
-            if (this.$options.json) {
-                return this.$logger.info(JSON.stringify(devices, null, 2));
-            }
-            if (table.length) {
-                this.$logger.info(table.toString());
+                this.$logger.info(color_1.color.bold("\n Available emulators"));
+                this.printEmulators(emulators);
             }
+        }
+        let index = 1;
+        await this.$devicesService.initialize({
+            platform: args[0],
+            deviceId: null,
+            skipInferPlatform: true,
+            skipDeviceDetectionInterval: true,
+            skipEmulatorStart: true,
+            fullDiscovery: true,
         });
+        if (!this.$options.json) {
+            this.$logger.info(color_1.color.bold("\n Connected devices & emulators"));
+        }
+        const table = (0, helpers_1.createTable)([
+            "#",
+            "Device Name",
+            "Platform",
+            "Device Identifier",
+            "Type",
+            "Status",
+            "Connection Type",
+        ], []);
+        let action;
+        if (this.$options.json) {
+            action = async (device) => {
+                devices.devices.push(device.deviceInfo);
+            };
+        }
+        else {
+            action = async (device) => {
+                table.push([
+                    (index++).toString(),
+                    device.deviceInfo.displayName || "",
+                    device.deviceInfo.platform || "",
+                    device.deviceInfo.identifier || "",
+                    device.deviceInfo.type || "",
+                    device.deviceInfo.status || "",
+                    device.deviceInfo.connectionTypes
+                        .map((type) => constants_1.DeviceConnectionType[type])
+                        .join(", "),
+                ]);
+            };
+        }
+        await this.$devicesService.execute(action, undefined, {
+            allowNoDevices: true,
+        });
+        if (this.$options.json) {
+            return this.$logger.info(JSON.stringify(devices, null, 2));
+        }
+        if (table.length) {
+            this.$logger.info(table.toString());
+        }
     }
     printEmulators(emulators) {
         const table = (0, helpers_1.createTable)([
@@ -124,12 +113,10 @@ class ListAndroidDevicesCommand {
         this.$devicePlatformsConstants = $devicePlatformsConstants;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const listDevicesCommand = this.$injector.resolve(ListDevicesCommand);
-            const platform = this.$devicePlatformsConstants.Android;
-            yield listDevicesCommand.execute([platform]);
-        });
+    async execute(args) {
+        const listDevicesCommand = this.$injector.resolve(ListDevicesCommand);
+        const platform = this.$devicePlatformsConstants.Android;
+        await listDevicesCommand.execute([platform]);
     }
 }
 yok_1.injector.registerCommand(["device|android", "devices|android"], ListAndroidDevicesCommand);
@@ -139,12 +126,10 @@ class ListiOSDevicesCommand {
         this.$devicePlatformsConstants = $devicePlatformsConstants;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const listDevicesCommand = this.$injector.resolve(ListDevicesCommand);
-            const platform = this.$devicePlatformsConstants.iOS;
-            yield listDevicesCommand.execute([platform]);
-        });
+    async execute(args) {
+        const listDevicesCommand = this.$injector.resolve(ListDevicesCommand);
+        const platform = this.$devicePlatformsConstants.iOS;
+        await listDevicesCommand.execute([platform]);
     }
 }
 yok_1.injector.registerCommand(["device|ios", "devices|ios"], ListiOSDevicesCommand);