nativescript 8.9.0-dev.2 → 8.9.0-dev.4

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,121 @@ 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" /* TrackActionNames.Debug */,
+            device,
+            additionalData: this.$mobileHelper.isiOSPlatform(device.deviceInfo.platform) &&
+                options &&
+                options.inspector
+                ? "Inspector" /* DebugTools.Inspector */
+                : "Chrome" /* DebugTools.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) {
+        // 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;
+        }
+        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 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 = 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 +155,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 +200,20 @@ 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,20 +9,21 @@ 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;