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

package/lib/controllers/debug-controller.js

@@ -5,6 +5,15 @@ 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");
@@ -30,117 +39,129 @@ class DebugController extends events_1.EventEmitter {
         this.$projectDataService = $projectDataService;
         this._platformDebugServices = {};
     }
-    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,
+    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);
         });
-        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));
     }
-    async disableDebugging(disableDebuggingData) {
-        const { deviceIdentifiers, projectDir } = disableDebuggingData;
-        for (const deviceIdentifier of deviceIdentifiers) {
-            const liveSyncProcessInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
-            if (liveSyncProcessInfo.currentSyncAction) {
-                await liveSyncProcessInfo.currentSyncAction;
+    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 });
             }
-            const currentDeviceDescriptor = this.getDeviceDescriptor(projectDir, deviceIdentifier);
-            if (currentDeviceDescriptor) {
-                currentDeviceDescriptor.debuggingEnabled = false;
+        });
+    }
+    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;
             }
             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.`);
+                attachDebuggerData.debugOptions = {
+                    chrome: true,
+                    start: true,
+                };
             }
-            await this.stopDebug(currentDevice.deviceInfo.identifier);
-            this.emit(constants_2.DEBUGGER_DETACHED_EVENT_NAME, { 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;
+        });
     }
-    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,
+    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}`);
+            }
+            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,
             };
-        }
-        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;
+            let debugInformation;
             try {
-                debugInformation = await this.attachDebugger(attachDebuggerData);
+                debugInformation = yield this.attachDebugger(attachDebuggerData);
             }
-            catch (innerErr) {
-                this.$logger.trace("Couldn't attach debugger with modified options.", innerErr);
-                throw err;
+            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;
+                }
             }
-        }
-        return debugInformation;
+            return debugInformation;
+        });
     }
     printDebugInformation(debugInformation, fireDebuggerAttachedEvent = true) {
         if (!!debugInformation.url) {
@@ -151,10 +172,12 @@ class DebugController extends events_1.EventEmitter {
         }
         return debugInformation;
     }
-    async stopDebug(deviceIdentifier) {
-        const device = this.$devicesService.getDeviceByIdentifier(deviceIdentifier);
-        const debugService = this.getDeviceDebugService(device);
-        await debugService.debugStop();
+    stopDebug(deviceIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = this.$devicesService.getDeviceByIdentifier(deviceIdentifier);
+            const debugService = this.getDeviceDebugService(device);
+            yield debugService.debugStop();
+        });
     }
     getDeviceDescriptor(projectDir, deviceIdentifier) {
         const deviceDescriptors = this.$liveSyncProcessDataService.getDeviceDescriptors(projectDir);
@@ -196,19 +219,22 @@ class DebugController extends events_1.EventEmitter {
         }
         return debugInfo;
     }
-    async enableDebuggingCore(projectDir, deviceIdentifier, debugOptions) {
-        const liveSyncProcessInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
-        if (liveSyncProcessInfo && liveSyncProcessInfo.currentSyncAction) {
-            await liveSyncProcessInfo.currentSyncAction;
-        }
-        return this.enableDebuggingCoreWithoutWaitingCurrentAction(projectDir, deviceIdentifier, debugOptions);
+    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);
+        });
     }
 }
-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,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeployController = void 0;
 const _ = require("lodash");
@@ -9,22 +18,22 @@ class DeployController {
         this.$devicesService = $devicesService;
         this.$prepareController = $prepareController;
     }
-    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));
+    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));
+        });
     }
 }
 exports.DeployController = DeployController;
 yok_1.injector.register("deployController", DeployController);
+//# sourceMappingURL=deploy-controller.js.map