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

package/lib/device-sockets/ios/app-debug-socket-proxy-factory.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.AppDebugSocketProxyFactory = void 0;
 const events_1 = require("events");
@@ -31,175 +22,169 @@ class AppDebugSocketProxyFactory extends events_1.EventEmitter {
     getTCPSocketProxy(deviceIdentifier, appId) {
         return this.deviceTcpServers[`${deviceIdentifier}-${appId}`];
     }
-    addTCPSocketProxy(device, appId, projectName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
-            const existingServer = this.deviceTcpServers[cacheKey];
-            if (existingServer) {
-                this.$errors.fail(`TCP socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
-            }
-            this.$logger.info("\nSetting up proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
-            const server = net.createServer({
-                allowHalfOpen: true,
+    async addTCPSocketProxy(device, appId, projectName, projectDir) {
+        const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
+        const existingServer = this.deviceTcpServers[cacheKey];
+        if (existingServer) {
+            this.$errors.fail(`TCP socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
+        }
+        this.$logger.info("\nSetting up proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
+        const server = net.createServer({
+            allowHalfOpen: true,
+        });
+        this.deviceTcpServers[cacheKey] = server;
+        server.on("connection", async (frontendSocket) => {
+            this.$logger.info("Frontend client connected.");
+            frontendSocket.on("end", () => {
+                this.$logger.info("Frontend socket closed!");
+                if (!this.$options.watch) {
+                    process.exit(0);
+                }
             });
-            this.deviceTcpServers[cacheKey] = server;
-            server.on("connection", (frontendSocket) => __awaiter(this, void 0, void 0, function* () {
-                this.$logger.info("Frontend client connected.");
-                frontendSocket.on("end", () => {
-                    this.$logger.info("Frontend socket closed!");
-                    if (!this.$options.watch) {
-                        process.exit(0);
-                    }
-                });
-                const appDebugSocket = yield device.getDebugSocket(appId, projectName, projectDir);
-                this.$logger.info("Backend socket created.");
-                appDebugSocket.on("end", () => {
-                    this.$logger.info("Backend socket closed!");
-                    if (!this.$options.watch) {
-                        process.exit(0);
-                    }
-                });
-                frontendSocket.on("close", () => __awaiter(this, void 0, void 0, function* () {
-                    this.$logger.info("Frontend socket closed");
-                    yield device.destroyDebugSocket(appId);
-                }));
-                appDebugSocket.on("close", () => {
-                    this.$logger.info("Backend socket closed");
-                    frontendSocket.destroy();
-                    server.close();
-                    delete this.deviceTcpServers[cacheKey];
-                });
-                appDebugSocket.pipe(frontendSocket);
-                frontendSocket.pipe(appDebugSocket);
-                frontendSocket.resume();
-            }));
-            const socketFileLocation = yield this.$tempService.path({
-                suffix: ".sock",
+            const appDebugSocket = await device.getDebugSocket(appId, projectName, projectDir);
+            this.$logger.info("Backend socket created.");
+            appDebugSocket.on("end", () => {
+                this.$logger.info("Backend socket closed!");
+                if (!this.$options.watch) {
+                    process.exit(0);
+                }
+            });
+            frontendSocket.on("close", async () => {
+                this.$logger.info("Frontend socket closed");
+                await device.destroyDebugSocket(appId);
+            });
+            appDebugSocket.on("close", () => {
+                this.$logger.info("Backend socket closed");
+                frontendSocket.destroy();
+                server.close();
+                delete this.deviceTcpServers[cacheKey];
             });
-            server.listen(socketFileLocation);
-            if (!this.$options.client) {
-                this.$logger.info("socket-file-location: " + socketFileLocation);
-            }
-            return server;
+            appDebugSocket.pipe(frontendSocket);
+            frontendSocket.pipe(appDebugSocket);
+            frontendSocket.resume();
         });
-    }
-    ensureWebSocketProxy(device, appId, projectName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingWebProxy = this.deviceWebServers[`${device.deviceInfo.identifier}-${appId}`];
-            const result = existingWebProxy ||
-                (yield this.addWebSocketProxy(device, appId, projectName, projectDir));
-            this.$logger.info("Opened localhost " + result.options.port);
-            return result;
+        const socketFileLocation = await this.$tempService.path({
+            suffix: ".sock",
         });
+        server.listen(socketFileLocation);
+        if (!this.$options.client) {
+            this.$logger.info("socket-file-location: " + socketFileLocation);
+        }
+        return server;
     }
-    addWebSocketProxy(device, appId, projectName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let clientConnectionLockRelease;
-            const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
-            const existingServer = this.deviceWebServers[cacheKey];
-            if (existingServer) {
-                this.$errors.fail(`Web socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
-            }
-            const localPort = yield this.$net.getAvailablePortInRange(41000);
-            this.$logger.info("\nSetting up debugger proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
-            let currentAppSocket = null;
-            let currentWebSocket = null;
-            const server = new ws.Server({
-                port: localPort,
-                verifyClient: (info, callback) => __awaiter(this, void 0, void 0, function* () {
-                    let acceptHandshake = true;
-                    clientConnectionLockRelease = null;
-                    try {
-                        clientConnectionLockRelease = yield this.$lockService.lock(`debug-connection-${device.deviceInfo.identifier}-${appId}.lock`);
-                        this.$logger.info("Frontend client connected.");
-                        let appDebugSocket;
-                        if (currentAppSocket) {
-                            currentAppSocket.removeAllListeners();
-                            currentAppSocket = null;
-                            if (currentWebSocket) {
-                                currentWebSocket.removeAllListeners();
-                                currentWebSocket.close();
-                                currentWebSocket = null;
-                            }
-                            yield device.destroyDebugSocket(appId);
-                        }
-                        appDebugSocket = yield device.getDebugSocket(appId, projectName, projectDir);
-                        currentAppSocket = appDebugSocket;
-                        this.$logger.info("Backend socket created.");
-                        info.req["__deviceSocket"] = appDebugSocket;
-                    }
-                    catch (err) {
-                        if (clientConnectionLockRelease) {
-                            clientConnectionLockRelease();
-                        }
-                        err.deviceIdentifier = device.deviceInfo.identifier;
-                        this.$logger.trace(err);
-                        this.emit(constants_1.CONNECTION_ERROR_EVENT_NAME, err);
-                        acceptHandshake = false;
-                        this.$logger.warn(`Cannot connect to device socket. The error message is '${err.message}'.`);
-                    }
-                    callback(acceptHandshake);
-                }),
-            });
-            this.deviceWebServers[cacheKey] = server;
-            server.on("connection", (webSocket, req) => {
-                currentWebSocket = webSocket;
-                const encoding = "utf16le";
-                const appDebugSocket = req["__deviceSocket"];
-                const packets = new ios_device_lib_1.MessageUnpackStream();
-                appDebugSocket.pipe(packets);
-                packets.on("data", (buffer) => {
-                    const message = buffer.toString(encoding);
-                    if (webSocket.readyState === webSocket.OPEN) {
-                        if (process.env.DEBUG_DEVTOOLS_SOCKETS) {
-                            console.log({
-                                msgFromRuntime: JSON.parse(message),
-                            });
+    async ensureWebSocketProxy(device, appId, projectName, projectDir) {
+        const existingWebProxy = this.deviceWebServers[`${device.deviceInfo.identifier}-${appId}`];
+        const result = existingWebProxy ||
+            (await this.addWebSocketProxy(device, appId, projectName, projectDir));
+        this.$logger.info("Opened localhost " + result.options.port);
+        return result;
+    }
+    async addWebSocketProxy(device, appId, projectName, projectDir) {
+        let clientConnectionLockRelease;
+        const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
+        const existingServer = this.deviceWebServers[cacheKey];
+        if (existingServer) {
+            this.$errors.fail(`Web socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
+        }
+        const localPort = await this.$net.getAvailablePortInRange(41000);
+        this.$logger.info("\nSetting up debugger proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
+        let currentAppSocket = null;
+        let currentWebSocket = null;
+        const server = new ws.Server({
+            port: localPort,
+            verifyClient: async (info, callback) => {
+                let acceptHandshake = true;
+                clientConnectionLockRelease = null;
+                try {
+                    clientConnectionLockRelease = await this.$lockService.lock(`debug-connection-${device.deviceInfo.identifier}-${appId}.lock`);
+                    this.$logger.info("Frontend client connected.");
+                    let appDebugSocket;
+                    if (currentAppSocket) {
+                        currentAppSocket.removeAllListeners();
+                        currentAppSocket = null;
+                        if (currentWebSocket) {
+                            currentWebSocket.removeAllListeners();
+                            currentWebSocket.close();
+                            currentWebSocket = null;
                         }
-                        webSocket.send(message);
+                        await device.destroyDebugSocket(appId);
                     }
-                    else {
-                        this.$logger.trace(`Received message ${message}, but unable to send it to webSocket as its state is: ${webSocket.readyState}`);
+                    appDebugSocket = await device.getDebugSocket(appId, projectName, projectDir);
+                    currentAppSocket = appDebugSocket;
+                    this.$logger.info("Backend socket created.");
+                    info.req["__deviceSocket"] = appDebugSocket;
+                }
+                catch (err) {
+                    if (clientConnectionLockRelease) {
+                        clientConnectionLockRelease();
                     }
-                });
-                webSocket.on("error", (err) => {
-                    this.$logger.trace("Error on debugger websocket", err);
-                });
-                appDebugSocket.on("error", (err) => {
-                    this.$logger.trace("Error on debugger deviceSocket", err);
-                });
-                webSocket.on("message", (message) => {
-                    const msg = message.toString();
+                    err.deviceIdentifier = device.deviceInfo.identifier;
+                    this.$logger.trace(err);
+                    this.emit(constants_1.CONNECTION_ERROR_EVENT_NAME, err);
+                    acceptHandshake = false;
+                    this.$logger.warn(`Cannot connect to device socket. The error message is '${err.message}'.`);
+                }
+                callback(acceptHandshake);
+            },
+        });
+        this.deviceWebServers[cacheKey] = server;
+        server.on("connection", (webSocket, req) => {
+            currentWebSocket = webSocket;
+            const encoding = "utf16le";
+            const appDebugSocket = req["__deviceSocket"];
+            const packets = new ios_device_lib_1.MessageUnpackStream();
+            appDebugSocket.pipe(packets);
+            packets.on("data", (buffer) => {
+                const message = buffer.toString(encoding);
+                if (webSocket.readyState === webSocket.OPEN) {
                     if (process.env.DEBUG_DEVTOOLS_SOCKETS) {
                         console.log({
-                            msgFromDevtools: JSON.parse(msg),
+                            msgFromRuntime: JSON.parse(message),
                         });
                     }
-                    const length = Buffer.byteLength(msg, encoding);
-                    const payload = Buffer.allocUnsafe(length + 4);
-                    payload.writeInt32BE(length, 0);
-                    payload.write(msg, 4, length, encoding);
-                    appDebugSocket.write(payload);
-                });
-                appDebugSocket.on("close", () => {
-                    currentAppSocket = null;
-                    this.$logger.trace("Backend socket closed!");
-                    webSocket.close();
-                });
-                webSocket.on("close", () => __awaiter(this, void 0, void 0, function* () {
-                    currentWebSocket = null;
-                    this.$logger.trace("Frontend socket closed!");
-                    appDebugSocket.unpipe(packets);
-                    packets.destroy();
-                    yield device.destroyDebugSocket(appId);
-                    if (!this.$options.watch) {
-                        process.exit(0);
-                    }
-                }));
-                clientConnectionLockRelease();
+                    webSocket.send(message);
+                }
+                else {
+                    this.$logger.trace(`Received message ${message}, but unable to send it to webSocket as its state is: ${webSocket.readyState}`);
+                }
+            });
+            webSocket.on("error", (err) => {
+                this.$logger.trace("Error on debugger websocket", err);
+            });
+            appDebugSocket.on("error", (err) => {
+                this.$logger.trace("Error on debugger deviceSocket", err);
+            });
+            webSocket.on("message", (message) => {
+                const msg = message.toString();
+                if (process.env.DEBUG_DEVTOOLS_SOCKETS) {
+                    console.log({
+                        msgFromDevtools: JSON.parse(msg),
+                    });
+                }
+                const length = Buffer.byteLength(msg, encoding);
+                const payload = Buffer.allocUnsafe(length + 4);
+                payload.writeInt32BE(length, 0);
+                payload.write(msg, 4, length, encoding);
+                appDebugSocket.write(payload);
+            });
+            appDebugSocket.on("close", () => {
+                currentAppSocket = null;
+                this.$logger.trace("Backend socket closed!");
+                webSocket.close();
+            });
+            webSocket.on("close", async () => {
+                currentWebSocket = null;
+                this.$logger.trace("Frontend socket closed!");
+                appDebugSocket.unpipe(packets);
+                packets.destroy();
+                await device.destroyDebugSocket(appId);
+                if (!this.$options.watch) {
+                    process.exit(0);
+                }
             });
-            return server;
+            clientConnectionLockRelease();
         });
+        return server;
     }
     removeAllProxies() {
         let deviceId;

package/lib/device-sockets/ios/notification.js

@@ -22,9 +22,9 @@ class IOSNotification extends events_1.EventEmitter {
         return `${appId}:NativeScript.Debug.${notification}`;
     }
 }
+exports.IOSNotification = IOSNotification;
 IOSNotification.REFRESH_REQUEST_NOTIFICATION_NAME = "RefreshRequest";
 IOSNotification.APP_REFRESH_STARTED_NOTIFICATION_NAME = "AppRefreshStarted";
 IOSNotification.ATTACH_REQUEST_NOTIFICATION_NAME = "AttachRequest";
 IOSNotification.READY_FOR_ATTACH_NOTIFICATION_NAME = "ReadyForAttach";
-exports.IOSNotification = IOSNotification;
 yok_1.injector.register("iOSNotification", IOSNotification);

package/lib/device-sockets/ios/socket-request-executor.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.IOSSocketRequestExecutor = void 0;
 const constants = require("../../common/constants");
@@ -18,38 +9,32 @@ class IOSSocketRequestExecutor {
         this.$iOSNotification = $iOSNotification;
         this.$iOSNotificationService = $iOSNotificationService;
     }
-    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 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);
     }
-    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 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;
     }
-    executeRequest(mainRequestName, successfulyExecutedNotificationName, appId, deviceId, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let isSuccessful = false;
-            try {
-                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;
-        });
+    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;
     }
 }
 exports.IOSSocketRequestExecutor = IOSSocketRequestExecutor;

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

@@ -46,7 +46,7 @@ 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);

package/lib/helpers/deploy-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.DeployCommandHelper = void 0;
 const yok_1 = require("../common/yok");
@@ -21,49 +12,53 @@ class DeployCommandHelper {
         this.$options = $options;
         this.$projectData = $projectData;
     }
-    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,
+    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: {
                     skipNativePrepare: additionalOptions && additionalOptions.skipNativePrepare,
-                    buildData,
-                };
-                return info;
+                },
             });
-            yield this.$deployController.deploy({ 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;
         });
+        await this.$deployController.deploy({ deviceDescriptors });
     }
 }
 exports.DeployCommandHelper = DeployCommandHelper;

package/lib/helpers/key-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 });
 const color_1 = require("../color");
 const yok_1 = require("../common/yok");
@@ -15,7 +6,7 @@ class KeyCommandHelper {
     constructor() {
         this.platform = "all";
         this.overrides = {};
-        this.onKeyPressed = (data) => __awaiter(this, void 0, void 0, function* () {
+        this.onKeyPressed = async (data) => {
             const key = data.toString();
             if (this.keyCommandExecutionBlocked && key !== "\u0003")
                 return;
@@ -34,7 +25,7 @@ class KeyCommandHelper {
                         if (keyCommand.willBlockKeyCommandExecution)
                             this.keyCommandExecutionBlocked = true;
                         if (this.overrides[key]) {
-                            if (!(yield this.overrides[key]())) {
+                            if (!(await this.overrides[key]())) {
                                 this.keyCommandExecutionBlocked = false;
                                 process.stdin.resume();
                                 return;
@@ -48,7 +39,7 @@ class KeyCommandHelper {
                             console.log(color_1.color.dim(` └${"─".repeat(lineLength)}┘`));
                             console.log("");
                         }
-                        const result = yield keyCommand.execute(this.platform);
+                        const result = await keyCommand.execute(this.platform);
                         this.keyCommandExecutionBlocked = false;
                         if (process.stdin.setRawMode) {
                             process.stdin.resume();
@@ -62,7 +53,7 @@ class KeyCommandHelper {
                 const $logger = yok_1.injector.resolve("logger");
                 $logger.error(e.message);
             }
-        });
+        };
     }
     addOverride(key, execute) {
         this.overrides[key] = execute;