nativescript 8.9.0-dev.2 → 8.9.0-dev.3

package/lib/controllers/build-controller.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.BuildController = void 0;
 const constants = require("../constants");
@@ -33,102 +24,93 @@ class BuildController extends events_1.EventEmitter {
     get $platformsDataService() {
         return this.$injector.resolve("platformsDataService");
     }
-    prepareAndBuild(buildData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$prepareController.prepare(buildData);
-            const result = yield this.build(buildData);
-            return result;
-        });
+    async prepareAndBuild(buildData) {
+        await this.$prepareController.prepare(buildData);
+        const result = await this.build(buildData);
+        return result;
     }
-    build(buildData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.info("Building project...");
-            const startTime = perf_hooks_1.performance.now();
-            const platform = buildData.platform.toLowerCase();
-            const projectData = this.$projectDataService.getProjectData(buildData.projectDir);
-            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
-            const action = "Build" /* constants.TrackActionNames.Build */;
-            const isForDevice = this.$mobileHelper.isAndroidPlatform(platform)
-                ? null
-                : buildData && buildData.buildForDevice;
-            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
-                action,
-                isForDevice,
-                platform,
-                projectDir: projectData.projectDir,
-                additionalData: `${buildData.release ? constants_1.Configurations.Release : constants_1.Configurations.Debug}_${buildData.clean
-                    ? "Clean" /* constants.BuildStates.Clean */
-                    : "Incremental" /* constants.BuildStates.Incremental */}`,
-            });
-            if (buildData.clean) {
-                yield platformData.platformProjectService.cleanProject(platformData.projectRoot);
-            }
-            const handler = (data) => {
-                this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data);
-                this.$logger.info(data.data.toString(), {
-                    [constants.LoggerConfigData.skipNewLine]: true,
-                });
-            };
-            yield (0, helpers_1.attachAwaitDetach)(constants.BUILD_OUTPUT_EVENT_NAME, platformData.platformProjectService, handler, platformData.platformProjectService.buildProject(platformData.projectRoot, projectData, buildData));
-            const buildInfoFileDir = platformData.getBuildOutputPath(buildData);
-            this.$buildInfoFileService.saveLocalBuildInfo(platformData, buildInfoFileDir);
-            const endTime = perf_hooks_1.performance.now();
-            const buildTime = (endTime - startTime) / 1000;
-            this.$logger.info("Project successfully built.");
-            this.$logger.info(`Build time: ${buildTime.toFixed(3)} s.`);
-            const result = yield this.$buildArtifactsService.getLatestAppPackagePath(platformData, buildData);
-            if (buildData.copyTo) {
-                this.$buildArtifactsService.copyLatestAppPackage(buildData.copyTo, platformData, buildData);
-            }
-            else {
-                this.$logger.info(`The build result is located at: ${result}`);
-            }
-            return result;
+    async build(buildData) {
+        this.$logger.info("Building project...");
+        const startTime = perf_hooks_1.performance.now();
+        const platform = buildData.platform.toLowerCase();
+        const projectData = this.$projectDataService.getProjectData(buildData.projectDir);
+        const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+        const action = "Build";
+        const isForDevice = this.$mobileHelper.isAndroidPlatform(platform)
+            ? null
+            : buildData && buildData.buildForDevice;
+        await this.$analyticsService.trackEventActionInGoogleAnalytics({
+            action,
+            isForDevice,
+            platform,
+            projectDir: projectData.projectDir,
+            additionalData: `${buildData.release ? constants_1.Configurations.Release : constants_1.Configurations.Debug}_${buildData.clean
+                ? "Clean"
+                : "Incremental"}`,
         });
+        if (buildData.clean) {
+            await platformData.platformProjectService.cleanProject(platformData.projectRoot);
+        }
+        const handler = (data) => {
+            this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data);
+            this.$logger.info(data.data.toString(), {
+                [constants.LoggerConfigData.skipNewLine]: true,
+            });
+        };
+        await (0, helpers_1.attachAwaitDetach)(constants.BUILD_OUTPUT_EVENT_NAME, platformData.platformProjectService, handler, platformData.platformProjectService.buildProject(platformData.projectRoot, projectData, buildData));
+        const buildInfoFileDir = platformData.getBuildOutputPath(buildData);
+        this.$buildInfoFileService.saveLocalBuildInfo(platformData, buildInfoFileDir);
+        const endTime = perf_hooks_1.performance.now();
+        const buildTime = (endTime - startTime) / 1000;
+        this.$logger.info("Project successfully built.");
+        this.$logger.info(`Build time: ${buildTime.toFixed(3)} s.`);
+        const result = await this.$buildArtifactsService.getLatestAppPackagePath(platformData, buildData);
+        if (buildData.copyTo) {
+            this.$buildArtifactsService.copyLatestAppPackage(buildData.copyTo, platformData, buildData);
+        }
+        else {
+            this.$logger.info(`The build result is located at: ${result}`);
+        }
+        return result;
     }
-    buildIfNeeded(buildData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let result = null;
-            const shouldBuildPlatform = yield this.shouldBuild(buildData);
-            if (shouldBuildPlatform) {
-                result = yield this.build(buildData);
-            }
-            return result;
-        });
+    async buildIfNeeded(buildData) {
+        let result = null;
+        const shouldBuildPlatform = await this.shouldBuild(buildData);
+        if (shouldBuildPlatform) {
+            result = await this.build(buildData);
+        }
+        return result;
     }
-    shouldBuild(buildData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const projectData = this.$projectDataService.getProjectData(buildData.projectDir);
-            const platformData = this.$platformsDataService.getPlatformData(buildData.platform, projectData);
-            const outputPath = buildData.outputPath || platformData.getBuildOutputPath(buildData);
-            const changesInfo = this.$projectChangesService.currentChanges ||
-                (yield this.$projectChangesService.checkForChanges(platformData, projectData, buildData));
-            if (changesInfo.changesRequireBuild) {
-                return true;
-            }
-            if (!this.$fs.exists(outputPath)) {
-                return true;
-            }
-            const validBuildOutputData = platformData.getValidBuildOutputData(buildData);
-            const packages = this.$buildArtifactsService.getAllAppPackages(outputPath, validBuildOutputData);
-            if (packages.length === 0) {
-                return true;
-            }
-            const prepareInfo = this.$projectChangesService.getPrepareInfo(platformData);
-            const buildInfo = this.$buildInfoFileService.getLocalBuildInfo(platformData, buildData);
-            if (!prepareInfo || !buildInfo) {
-                return true;
-            }
-            if (buildData.clean) {
-                return true;
-            }
-            if (prepareInfo.time === buildInfo.prepareTime) {
-                return false;
-            }
-            return prepareInfo.changesRequireBuildTime !== buildInfo.prepareTime;
-        });
+    async shouldBuild(buildData) {
+        const projectData = this.$projectDataService.getProjectData(buildData.projectDir);
+        const platformData = this.$platformsDataService.getPlatformData(buildData.platform, projectData);
+        const outputPath = buildData.outputPath || platformData.getBuildOutputPath(buildData);
+        const changesInfo = this.$projectChangesService.currentChanges ||
+            (await this.$projectChangesService.checkForChanges(platformData, projectData, buildData));
+        if (changesInfo.changesRequireBuild) {
+            return true;
+        }
+        if (!this.$fs.exists(outputPath)) {
+            return true;
+        }
+        const validBuildOutputData = platformData.getValidBuildOutputData(buildData);
+        const packages = this.$buildArtifactsService.getAllAppPackages(outputPath, validBuildOutputData);
+        if (packages.length === 0) {
+            return true;
+        }
+        const prepareInfo = this.$projectChangesService.getPrepareInfo(platformData);
+        const buildInfo = this.$buildInfoFileService.getLocalBuildInfo(platformData, buildData);
+        if (!prepareInfo || !buildInfo) {
+            return true;
+        }
+        if (buildData.clean) {
+            return true;
+        }
+        if (prepareInfo.time === buildInfo.prepareTime) {
+            return false;
+        }
+        return prepareInfo.changesRequireBuildTime !== buildInfo.prepareTime;
     }
 }
 exports.BuildController = BuildController;
 yok_1.injector.register("buildController", BuildController);
-//# sourceMappingURL=build-controller.js.map

package/lib/controllers/debug-controller.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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.DebugController = void 0;
 const decorators_1 = require("../common/decorators");
@@ -39,129 +30,117 @@ class DebugController extends events_1.EventEmitter {
         this.$projectDataService = $projectDataService;
         this._platformDebugServices = {};
     }
-    startDebug(debugData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { debugOptions: options } = debugData;
-            const device = this.$devicesService.getDeviceByIdentifier(debugData.deviceIdentifier);
-            if (!device) {
-                this.$errors.fail(`Cannot find device with identifier ${debugData.deviceIdentifier}.`);
-            }
-            if (device.deviceInfo.status !== constants_1.CONNECTED_STATUS) {
-                this.$errors.fail(`The device with identifier ${debugData.deviceIdentifier} is unreachable. Make sure it is Trusted and try again.`);
-            }
-            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
-                action: "Debug" /* TrackActionNames.Debug */,
-                device,
-                additionalData: this.$mobileHelper.isiOSPlatform(device.deviceInfo.platform) &&
-                    options &&
-                    options.inspector
-                    ? "Inspector" /* DebugTools.Inspector */
-                    : "Chrome" /* DebugTools.Chrome */,
-                projectDir: debugData.projectDir,
-            });
-            if (!(yield device.applicationManager.isApplicationInstalled(debugData.applicationIdentifier))) {
-                this.$errors.fail(`The application ${debugData.applicationIdentifier} is not installed on device with identifier ${debugData.deviceIdentifier}.`);
-            }
-            const debugService = this.getDeviceDebugService(device);
-            if (!debugService) {
-                this.$errors.fail(`Unsupported device OS: ${device.deviceInfo.platform}. You can debug your applications only on iOS or Android.`);
-            }
-            const debugOptions = _.cloneDeep(options);
-            const debugResultInfo = yield debugService.debug(debugData, debugOptions);
-            return this.getDebugInformation(debugResultInfo, device.deviceInfo.identifier);
+    async startDebug(debugData) {
+        const { debugOptions: options } = debugData;
+        const device = this.$devicesService.getDeviceByIdentifier(debugData.deviceIdentifier);
+        if (!device) {
+            this.$errors.fail(`Cannot find device with identifier ${debugData.deviceIdentifier}.`);
+        }
+        if (device.deviceInfo.status !== constants_1.CONNECTED_STATUS) {
+            this.$errors.fail(`The device with identifier ${debugData.deviceIdentifier} is unreachable. Make sure it is Trusted and try again.`);
+        }
+        await this.$analyticsService.trackEventActionInGoogleAnalytics({
+            action: "Debug",
+            device,
+            additionalData: this.$mobileHelper.isiOSPlatform(device.deviceInfo.platform) &&
+                options &&
+                options.inspector
+                ? "Inspector"
+                : "Chrome",
+            projectDir: debugData.projectDir,
         });
+        if (!(await device.applicationManager.isApplicationInstalled(debugData.applicationIdentifier))) {
+            this.$errors.fail(`The application ${debugData.applicationIdentifier} is not installed on device with identifier ${debugData.deviceIdentifier}.`);
+        }
+        const debugService = this.getDeviceDebugService(device);
+        if (!debugService) {
+            this.$errors.fail(`Unsupported device OS: ${device.deviceInfo.platform}. You can debug your applications only on iOS or Android.`);
+        }
+        const debugOptions = _.cloneDeep(options);
+        const debugResultInfo = await debugService.debug(debugData, debugOptions);
+        return this.getDebugInformation(debugResultInfo, device.deviceInfo.identifier);
     }
     enableDebugging(enableDebuggingData) {
         const { deviceIdentifiers } = enableDebuggingData;
         return _.map(deviceIdentifiers, (deviceIdentifier) => this.enableDebuggingCore(enableDebuggingData.projectDir, deviceIdentifier, enableDebuggingData.debugOptions));
     }
-    disableDebugging(disableDebuggingData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { deviceIdentifiers, projectDir } = disableDebuggingData;
-            for (const deviceIdentifier of deviceIdentifiers) {
-                const liveSyncProcessInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
-                if (liveSyncProcessInfo.currentSyncAction) {
-                    yield liveSyncProcessInfo.currentSyncAction;
-                }
-                const currentDeviceDescriptor = this.getDeviceDescriptor(projectDir, deviceIdentifier);
-                if (currentDeviceDescriptor) {
-                    currentDeviceDescriptor.debuggingEnabled = false;
-                }
-                else {
-                    this.$errors.fail(`Couldn't disable debugging for ${deviceIdentifier}`);
-                }
-                const currentDevice = this.$devicesService.getDeviceByIdentifier(currentDeviceDescriptor.identifier);
-                if (!currentDevice) {
-                    this.$errors.fail(`Couldn't disable debugging for ${deviceIdentifier}. Could not find device.`);
-                }
-                yield this.stopDebug(currentDevice.deviceInfo.identifier);
-                this.emit(constants_2.DEBUGGER_DETACHED_EVENT_NAME, { deviceIdentifier });
+    async disableDebugging(disableDebuggingData) {
+        const { deviceIdentifiers, projectDir } = disableDebuggingData;
+        for (const deviceIdentifier of deviceIdentifiers) {
+            const liveSyncProcessInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
+            if (liveSyncProcessInfo.currentSyncAction) {
+                await liveSyncProcessInfo.currentSyncAction;
             }
-        });
-    }
-    attachDebugger(attachDebuggerData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Default values
-            if (attachDebuggerData.debugOptions) {
-                attachDebuggerData.debugOptions.chrome =
-                    attachDebuggerData.debugOptions.chrome === undefined
-                        ? true
-                        : attachDebuggerData.debugOptions.chrome;
-                attachDebuggerData.debugOptions.start =
-                    attachDebuggerData.debugOptions.start === undefined
-                        ? true
-                        : attachDebuggerData.debugOptions.start;
+            const currentDeviceDescriptor = this.getDeviceDescriptor(projectDir, deviceIdentifier);
+            if (currentDeviceDescriptor) {
+                currentDeviceDescriptor.debuggingEnabled = false;
             }
             else {
-                attachDebuggerData.debugOptions = {
-                    chrome: true,
-                    start: true,
-                };
+                this.$errors.fail(`Couldn't disable debugging for ${deviceIdentifier}`);
             }
-            const projectData = this.$projectDataService.getProjectData(attachDebuggerData.projectDir);
-            const debugData = this.$debugDataService.getDebugData(attachDebuggerData.deviceIdentifier, projectData, attachDebuggerData.debugOptions);
-            // const platformData = this.$platformsDataService.getPlatformData(settings.platform, projectData);
-            // Of the properties below only `buildForDevice` and `release` are currently used.
-            // Leaving the others with placeholder values so that they may not be forgotten in future implementations.
-            const debugInfo = yield this.startDebug(debugData);
-            const result = this.printDebugInformation(debugInfo, attachDebuggerData.debugOptions.forceDebuggerAttachedEvent);
-            return result;
-        });
-    }
-    enableDebuggingCoreWithoutWaitingCurrentAction(projectDir, deviceIdentifier, debugOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceDescriptor = this.getDeviceDescriptor(projectDir, deviceIdentifier);
-            if (!deviceDescriptor) {
-                this.$errors.fail(`Couldn't enable debugging for ${deviceIdentifier}`);
+            const currentDevice = this.$devicesService.getDeviceByIdentifier(currentDeviceDescriptor.identifier);
+            if (!currentDevice) {
+                this.$errors.fail(`Couldn't disable debugging for ${deviceIdentifier}. Could not find device.`);
             }
-            deviceDescriptor.debuggingEnabled = true;
-            deviceDescriptor.debugOptions = debugOptions;
-            const currentDeviceInstance = this.$devicesService.getDeviceByIdentifier(deviceIdentifier);
-            const attachDebuggerData = {
-                deviceIdentifier,
-                isEmulator: currentDeviceInstance.isEmulator,
-                outputPath: deviceDescriptor.buildData.outputPath,
-                platform: currentDeviceInstance.deviceInfo.platform,
-                projectDir,
-                debugOptions,
+            await this.stopDebug(currentDevice.deviceInfo.identifier);
+            this.emit(constants_2.DEBUGGER_DETACHED_EVENT_NAME, { deviceIdentifier });
+        }
+    }
+    async attachDebugger(attachDebuggerData) {
+        if (attachDebuggerData.debugOptions) {
+            attachDebuggerData.debugOptions.chrome =
+                attachDebuggerData.debugOptions.chrome === undefined
+                    ? true
+                    : attachDebuggerData.debugOptions.chrome;
+            attachDebuggerData.debugOptions.start =
+                attachDebuggerData.debugOptions.start === undefined
+                    ? true
+                    : attachDebuggerData.debugOptions.start;
+        }
+        else {
+            attachDebuggerData.debugOptions = {
+                chrome: true,
+                start: true,
             };
-            let debugInformation;
+        }
+        const projectData = this.$projectDataService.getProjectData(attachDebuggerData.projectDir);
+        const debugData = this.$debugDataService.getDebugData(attachDebuggerData.deviceIdentifier, projectData, attachDebuggerData.debugOptions);
+        const debugInfo = await this.startDebug(debugData);
+        const result = this.printDebugInformation(debugInfo, attachDebuggerData.debugOptions.forceDebuggerAttachedEvent);
+        return result;
+    }
+    async enableDebuggingCoreWithoutWaitingCurrentAction(projectDir, deviceIdentifier, debugOptions) {
+        const deviceDescriptor = this.getDeviceDescriptor(projectDir, deviceIdentifier);
+        if (!deviceDescriptor) {
+            this.$errors.fail(`Couldn't enable debugging for ${deviceIdentifier}`);
+        }
+        deviceDescriptor.debuggingEnabled = true;
+        deviceDescriptor.debugOptions = debugOptions;
+        const currentDeviceInstance = this.$devicesService.getDeviceByIdentifier(deviceIdentifier);
+        const attachDebuggerData = {
+            deviceIdentifier,
+            isEmulator: currentDeviceInstance.isEmulator,
+            outputPath: deviceDescriptor.buildData.outputPath,
+            platform: currentDeviceInstance.deviceInfo.platform,
+            projectDir,
+            debugOptions,
+        };
+        let debugInformation;
+        try {
+            debugInformation = await this.attachDebugger(attachDebuggerData);
+        }
+        catch (err) {
+            this.$logger.trace("Couldn't attach debugger, will modify options and try again.", err);
+            attachDebuggerData.debugOptions.start = false;
             try {
-                debugInformation = yield this.attachDebugger(attachDebuggerData);
+                debugInformation = await this.attachDebugger(attachDebuggerData);
             }
-            catch (err) {
-                this.$logger.trace("Couldn't attach debugger, will modify options and try again.", err);
-                attachDebuggerData.debugOptions.start = false;
-                try {
-                    debugInformation = yield this.attachDebugger(attachDebuggerData);
-                }
-                catch (innerErr) {
-                    this.$logger.trace("Couldn't attach debugger with modified options.", innerErr);
-                    throw err;
-                }
+            catch (innerErr) {
+                this.$logger.trace("Couldn't attach debugger with modified options.", innerErr);
+                throw err;
             }
-            return debugInformation;
-        });
+        }
+        return debugInformation;
     }
     printDebugInformation(debugInformation, fireDebuggerAttachedEvent = true) {
         if (!!debugInformation.url) {
@@ -172,12 +151,10 @@ class DebugController extends events_1.EventEmitter {
         }
         return debugInformation;
     }
-    stopDebug(deviceIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const device = this.$devicesService.getDeviceByIdentifier(deviceIdentifier);
-            const debugService = this.getDeviceDebugService(device);
-            yield debugService.debugStop();
-        });
+    async stopDebug(deviceIdentifier) {
+        const device = this.$devicesService.getDeviceByIdentifier(deviceIdentifier);
+        const debugService = this.getDeviceDebugService(device);
+        await debugService.debugStop();
     }
     getDeviceDescriptor(projectDir, deviceIdentifier) {
         const deviceDescriptors = this.$liveSyncProcessDataService.getDeviceDescriptors(projectDir);
@@ -219,22 +196,19 @@ class DebugController extends events_1.EventEmitter {
         }
         return debugInfo;
     }
-    enableDebuggingCore(projectDir, deviceIdentifier, debugOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const liveSyncProcessInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
-            if (liveSyncProcessInfo && liveSyncProcessInfo.currentSyncAction) {
-                yield liveSyncProcessInfo.currentSyncAction;
-            }
-            return this.enableDebuggingCoreWithoutWaitingCurrentAction(projectDir, deviceIdentifier, debugOptions);
-        });
+    async enableDebuggingCore(projectDir, deviceIdentifier, debugOptions) {
+        const liveSyncProcessInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
+        if (liveSyncProcessInfo && liveSyncProcessInfo.currentSyncAction) {
+            await liveSyncProcessInfo.currentSyncAction;
+        }
+        return this.enableDebuggingCoreWithoutWaitingCurrentAction(projectDir, deviceIdentifier, debugOptions);
     }
 }
+exports.DebugController = DebugController;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], DebugController.prototype, "startDebug", null);
 __decorate([
     (0, decorators_1.performanceLog)()
 ], DebugController.prototype, "enableDebuggingCoreWithoutWaitingCurrentAction", null);
-exports.DebugController = DebugController;
 yok_1.injector.register("debugController", DebugController);
-//# sourceMappingURL=debug-controller.js.map

package/lib/controllers/deploy-controller.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.DeployController = void 0;
 const _ = require("lodash");
@@ -18,22 +9,22 @@ class DeployController {
         this.$devicesService = $devicesService;
         this.$prepareController = $prepareController;
     }
-    deploy(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { deviceDescriptors } = data;
-            const executeAction = (device) => __awaiter(this, void 0, void 0, function* () {
-                const deviceDescriptor = _.find(deviceDescriptors, (dd) => dd.identifier === device.deviceInfo.identifier);
-                const prepareData = Object.assign(Object.assign({}, deviceDescriptor.buildData), { nativePrepare: {
-                        skipNativePrepare: !!deviceDescriptor.skipNativePrepare,
-                    } });
-                yield this.$prepareController.prepare(prepareData);
-                const packageFilePath = yield deviceDescriptor.buildAction();
-                yield this.$deviceInstallAppService.installOnDevice(device, Object.assign(Object.assign({}, deviceDescriptor.buildData), { buildForDevice: !device.isEmulator }), packageFilePath);
-            });
-            yield this.$devicesService.execute(executeAction, (device) => _.some(deviceDescriptors, (deviceDescriptor) => deviceDescriptor.identifier === device.deviceInfo.identifier));
-        });
+    async deploy(data) {
+        const { deviceDescriptors } = data;
+        const executeAction = async (device) => {
+            const deviceDescriptor = _.find(deviceDescriptors, (dd) => dd.identifier === device.deviceInfo.identifier);
+            const prepareData = {
+                ...deviceDescriptor.buildData,
+                nativePrepare: {
+                    skipNativePrepare: !!deviceDescriptor.skipNativePrepare,
+                },
+            };
+            await this.$prepareController.prepare(prepareData);
+            const packageFilePath = await deviceDescriptor.buildAction();
+            await this.$deviceInstallAppService.installOnDevice(device, { ...deviceDescriptor.buildData, buildForDevice: !device.isEmulator }, packageFilePath);
+        };
+        await this.$devicesService.execute(executeAction, (device) => _.some(deviceDescriptors, (deviceDescriptor) => deviceDescriptor.identifier === device.deviceInfo.identifier));
     }
 }
 exports.DeployController = DeployController;
 yok_1.injector.register("deployController", DeployController);
-//# sourceMappingURL=deploy-controller.js.map