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

package/lib/common/mobile/mobile-core/ios-device-discovery.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.IOSDeviceDiscovery = void 0;
 const device_discovery_1 = require("./device-discovery");
@@ -22,36 +13,34 @@ class IOSDeviceDiscovery extends device_discovery_1.DeviceDiscovery {
         this.$iosDeviceOperations = $iosDeviceOperations;
         this.$devicePlatformsConstants = $devicePlatformsConstants;
     }
-    startLookingForDevices(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.trace("Options for ios-device-discovery", options);
-            if (options &&
-                options.platform &&
-                (!this.$mobileHelper.isApplePlatform(options.platform) ||
-                    options.emulator)) {
-                return;
-            }
-            if (this.$mobileHelper.isvisionOSPlatform(options.platform)) {
-                // look for ios devices - same logic.
-                options.platform = this.$devicePlatformsConstants.iOS;
+    async startLookingForDevices(options) {
+        this.$logger.trace("Options for ios-device-discovery", options);
+        if (options &&
+            options.platform &&
+            (!this.$mobileHelper.isApplePlatform(options.platform) ||
+                options.emulator)) {
+            return;
+        }
+        if (this.$mobileHelper.isvisionOSPlatform(options.platform)) {
+            // look for ios devices - same logic.
+            options.platform = this.$devicePlatformsConstants.iOS;
+        }
+        await this.$iosDeviceOperations.startLookingForDevices((deviceInfo) => {
+            const device = this.createDevice(deviceInfo);
+            this.addDevice(device);
+        }, (deviceInfo) => {
+            const currentDevice = this.getDevice(deviceInfo.deviceId);
+            if (currentDevice) {
+                const device = this.createDevice(deviceInfo);
+                this.updateDeviceInfo(device);
             }
-            yield this.$iosDeviceOperations.startLookingForDevices((deviceInfo) => {
+            else {
                 const device = this.createDevice(deviceInfo);
                 this.addDevice(device);
-            }, (deviceInfo) => {
-                const currentDevice = this.getDevice(deviceInfo.deviceId);
-                if (currentDevice) {
-                    const device = this.createDevice(deviceInfo);
-                    this.updateDeviceInfo(device);
-                }
-                else {
-                    const device = this.createDevice(deviceInfo);
-                    this.addDevice(device);
-                }
-            }, (deviceInfo) => {
-                this.removeDevice(deviceInfo.deviceId);
-            }, options);
-        });
+            }
+        }, (deviceInfo) => {
+            this.removeDevice(deviceInfo.deviceId);
+        }, options);
     }
     createDevice(deviceActionInfo) {
         const device = this.$injector.resolve(ios_device_1.IOSDevice, {

package/lib/common/mobile/mobile-core/ios-simulator-discovery.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.IOSSimulatorDiscovery = void 0;
 const device_discovery_1 = require("./device-discovery");
@@ -26,65 +17,59 @@ class IOSSimulatorDiscovery extends device_discovery_1.DeviceDiscovery {
         this.cachedSimulators = [];
         this.availableSimulators = {};
     }
-    startLookingForDevices(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (options &&
-                options.platform &&
-                !this.$mobileHelper.isiOSPlatform(options.platform)) {
-                return;
-            }
-            return this.checkForDevices();
-        });
+    async startLookingForDevices(options) {
+        if (options &&
+            options.platform &&
+            !this.$mobileHelper.isiOSPlatform(options.platform)) {
+            return;
+        }
+        return this.checkForDevices();
     }
-    checkForDevices() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.$hostInfo.isDarwin) {
-                const currentSimulators = yield this.$iOSSimResolver.iOSSim.getRunningSimulators();
-                // Remove old simulators
-                _(this.cachedSimulators)
-                    .reject((s) => _.some(currentSimulators, (simulator) => simulator &&
-                    s &&
-                    simulator.id === s.id &&
-                    simulator.state === s.state))
-                    .each((s) => this.deleteAndRemoveDevice(s));
-                // Add new simulators
-                _(currentSimulators)
-                    .reject((s) => _.some(this.cachedSimulators, (simulator) => simulator &&
-                    s &&
-                    simulator.id === s.id &&
-                    simulator.state === s.state))
-                    .each((s) => this.createAndAddDevice(s));
-            }
-        });
+    async checkForDevices() {
+        if (this.$hostInfo.isDarwin) {
+            const currentSimulators = await this.$iOSSimResolver.iOSSim.getRunningSimulators();
+            // Remove old simulators
+            _(this.cachedSimulators)
+                .reject((s) => _.some(currentSimulators, (simulator) => simulator &&
+                s &&
+                simulator.id === s.id &&
+                simulator.state === s.state))
+                .each((s) => this.deleteAndRemoveDevice(s));
+            // Add new simulators
+            _(currentSimulators)
+                .reject((s) => _.some(this.cachedSimulators, (simulator) => simulator &&
+                s &&
+                simulator.id === s.id &&
+                simulator.state === s.state))
+                .each((s) => this.createAndAddDevice(s));
+        }
     }
-    checkForAvailableSimulators() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$hostInfo.isDarwin) {
-                return [];
+    async checkForAvailableSimulators() {
+        if (!this.$hostInfo.isDarwin) {
+            return [];
+        }
+        const simulators = (await this.$iOSEmulatorServices.getEmulatorImages())
+            .devices;
+        const currentSimulators = _.values(this.availableSimulators);
+        const lostSimulators = [];
+        const foundSimulators = [];
+        for (const simulator of currentSimulators) {
+            if (!_.find(this.availableSimulators, (s) => s.imageIdentifier === simulator.imageIdentifier)) {
+                lostSimulators.push(simulator);
             }
-            const simulators = (yield this.$iOSEmulatorServices.getEmulatorImages())
-                .devices;
-            const currentSimulators = _.values(this.availableSimulators);
-            const lostSimulators = [];
-            const foundSimulators = [];
-            for (const simulator of currentSimulators) {
-                if (!_.find(this.availableSimulators, (s) => s.imageIdentifier === simulator.imageIdentifier)) {
-                    lostSimulators.push(simulator);
-                }
+        }
+        for (const simulator of simulators) {
+            if (!this.availableSimulators[simulator.imageIdentifier]) {
+                foundSimulators.push(simulator);
             }
-            for (const simulator of simulators) {
-                if (!this.availableSimulators[simulator.imageIdentifier]) {
-                    foundSimulators.push(simulator);
-                }
-            }
-            if (lostSimulators.length) {
-                this.raiseOnEmulatorImagesLost(lostSimulators);
-            }
-            if (foundSimulators.length) {
-                this.raiseOnEmulatorImagesFound(foundSimulators);
-            }
-            return simulators;
-        });
+        }
+        if (lostSimulators.length) {
+            this.raiseOnEmulatorImagesLost(lostSimulators);
+        }
+        if (foundSimulators.length) {
+            this.raiseOnEmulatorImagesFound(foundSimulators);
+        }
+        return simulators;
     }
     createAndAddDevice(simulator) {
         this.cachedSimulators.push(_.cloneDeep(simulator));

package/lib/common/mobile/mobile-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.MobileHelper = void 0;
 const helpers = require("../helpers");
@@ -78,26 +69,24 @@ class MobileHelper {
     isiOSTablet(deviceName) {
         return deviceName && deviceName.toLowerCase().indexOf("ipad") !== -1;
     }
-    getDeviceFileContent(device, deviceFilePath, projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const uniqueFilePath = yield this.$tempService.path({ suffix: ".tmp" });
-            const platform = device.deviceInfo.platform.toLowerCase();
-            try {
-                yield device.fileSystem.getFile(deviceFilePath, projectData.projectIdentifiers[platform], uniqueFilePath);
-            }
-            catch (e) {
-                return null;
-            }
-            if (this.$fs.exists(uniqueFilePath)) {
-                const text = this.$fs.readText(uniqueFilePath);
-                shell.rm(uniqueFilePath);
-                return text;
-            }
+    async getDeviceFileContent(device, deviceFilePath, projectData) {
+        const uniqueFilePath = await this.$tempService.path({ suffix: ".tmp" });
+        const platform = device.deviceInfo.platform.toLowerCase();
+        try {
+            await device.fileSystem.getFile(deviceFilePath, projectData.projectIdentifiers[platform], uniqueFilePath);
+        }
+        catch (e) {
             return null;
-        });
+        }
+        if (this.$fs.exists(uniqueFilePath)) {
+            const text = this.$fs.readText(uniqueFilePath);
+            shell.rm(uniqueFilePath);
+            return text;
+        }
+        return null;
     }
 }
-MobileHelper.DEVICE_PATH_SEPARATOR = "/";
 exports.MobileHelper = MobileHelper;
+MobileHelper.DEVICE_PATH_SEPARATOR = "/";
 yok_1.injector.register("mobileHelper", MobileHelper);
 //# sourceMappingURL=mobile-helper.js.map

package/lib/common/mobile/wp8/wp8-emulator-services.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 path = require("path");
 const yok_1 = require("../../yok");
@@ -21,57 +12,39 @@ class Wp8EmulatorServices {
         this.$logger = $logger;
         this.$childProcess = $childProcess;
     }
-    getEmulatorId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return "";
-        });
+    async getEmulatorId() {
+        return "";
     }
-    getRunningEmulator(image) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return null;
-        });
+    async getRunningEmulator(image) {
+        return null;
     }
-    getRunningEmulatorImageIdentifier(emulatorId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return null;
-        });
+    async getRunningEmulatorImageIdentifier(emulatorId) {
+        return null;
     }
-    getRunningEmulatorIds() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return [];
-        });
+    async getRunningEmulatorIds() {
+        return [];
     }
-    startEmulator() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return null;
-        });
+    async startEmulator() {
+        return null;
     }
-    runApplicationOnEmulator(app, emulatorOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.info("Starting Windows Phone Emulator");
-            const emulatorStarter = this.getPathToEmulatorStarter();
-            this.$childProcess
-                .spawn(emulatorStarter, ["/installlaunch", app, "/targetdevice:xd"], {
-                stdio: "ignore",
-                detached: true,
-            })
-                .unref();
-        });
+    async runApplicationOnEmulator(app, emulatorOptions) {
+        this.$logger.info("Starting Windows Phone Emulator");
+        const emulatorStarter = this.getPathToEmulatorStarter();
+        this.$childProcess
+            .spawn(emulatorStarter, ["/installlaunch", app, "/targetdevice:xd"], {
+            stdio: "ignore",
+            detached: true,
+        })
+            .unref();
     }
-    getEmulatorImages() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return { devices: [], errors: [] };
-        });
+    async getEmulatorImages() {
+        return { devices: [], errors: [] };
     }
-    getRunningEmulators() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return [];
-        });
+    async getRunningEmulators() {
+        return [];
     }
-    getRunningEmulatorName() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return "";
-        });
+    async getRunningEmulatorName() {
+        return "";
     }
     getPathToEmulatorStarter() {
         return path.join(Wp8EmulatorServices.programFilesPath, Wp8EmulatorServices.WP8_LAUNCHER_PATH, Wp8EmulatorServices.WP8_LAUNCHER);

package/lib/common/opener.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Opener = void 0;
-const xopen = require("open");
+const open_1 = require("open");
 const yok_1 = require("./yok");
 class Opener {
     open(target, appname) {
-        return xopen(target, {
+        return (0, open_1.default)(target, {
             app: {
                 name: appname,
             },

package/lib/common/prompter.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.Prompter = void 0;
 const prompt = require("prompts");
@@ -25,116 +16,110 @@ class Prompter {
             this.ctrlcReader.close();
         }
     }
-    get(questions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.muteStdout();
-                if (!helpers.isInteractive()) {
-                    if (_.some(questions, (s) => !s.default)) {
-                        throw new Error("Console is not interactive and no default action specified.");
-                    }
-                    else {
-                        const result = {};
-                        _.each(questions, (s) => {
-                            // Curly brackets needed because s.default() may return false and break the loop
-                            result[s.name] = s.default();
-                        });
-                        return result;
-                    }
+    async get(questions) {
+        try {
+            this.muteStdout();
+            if (!helpers.isInteractive()) {
+                if (_.some(questions, (s) => !s.default)) {
+                    throw new Error("Console is not interactive and no default action specified.");
                 }
                 else {
-                    const result = yield prompt.prompt(questions);
+                    const result = {};
+                    _.each(questions, (s) => {
+                        // Curly brackets needed because s.default() may return false and break the loop
+                        result[s.name] = s.default();
+                    });
                     return result;
                 }
             }
-            finally {
-                this.unmuteStdout();
+            else {
+                const result = await prompt.prompt(questions);
+                return result;
             }
-        });
+        }
+        finally {
+            this.unmuteStdout();
+        }
     }
-    getPassword(message, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = {
-                message,
-                type: "password",
-                name: "password",
-                validate: (value) => {
-                    const allowEmpty = options && options.allowEmpty;
-                    return !allowEmpty && !value ? "Password must be non-empty" : true;
-                },
-            };
-            const result = yield this.get([schema]);
-            return result.password;
-        });
+    async getPassword(message, options) {
+        const schema = {
+            message,
+            type: "password",
+            name: "password",
+            validate: (value) => {
+                const allowEmpty = options && options.allowEmpty;
+                return !allowEmpty && !value ? "Password must be non-empty" : true;
+            },
+        };
+        const result = await this.get([schema]);
+        return result.password;
     }
-    getString(message, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = {
-                message,
-                type: "text",
-                name: "inputString",
-                validate: (value) => {
-                    const doesNotAllowEmpty = options && _.has(options, "allowEmpty") && !options.allowEmpty;
-                    return doesNotAllowEmpty && !value
-                        ? `${message} must be non-empty`
-                        : true;
-                },
-                default: options && options.defaultAction,
-            };
-            const result = yield this.get([schema]);
-            return result.inputString;
-        });
+    async getString(message, options) {
+        const schema = {
+            message,
+            type: "text",
+            name: "inputString",
+            validate: (value) => {
+                const doesNotAllowEmpty = options && _.has(options, "allowEmpty") && !options.allowEmpty;
+                return doesNotAllowEmpty && !value
+                    ? `${message} must be non-empty`
+                    : true;
+            },
+            default: options && options.defaultAction,
+        };
+        const result = await this.get([schema]);
+        return result.inputString;
     }
-    promptForChoice(promptMessage, choices, multiple = false, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = Object.assign({ message: promptMessage, type: multiple ? "multiselect" : "select", name: "userAnswer", choices }, options);
-            const result = yield this.get([schema]);
-            const extractValue = (choice) => {
-                if (typeof choice === "object") {
-                    return choice.value || choice;
-                }
-                if (typeof choice === "string") {
-                    return choice;
-                }
-                if (typeof choice === "number") {
-                    return choices[choice];
-                }
-            };
-            return multiple
-                ? result.userAnswer.map(extractValue)
-                : extractValue(result.userAnswer);
-        });
+    async promptForChoice(promptMessage, choices, multiple = false, options = {}) {
+        const schema = {
+            message: promptMessage,
+            type: multiple ? "multiselect" : "select",
+            name: "userAnswer",
+            choices,
+            ...options,
+        };
+        const result = await this.get([schema]);
+        const extractValue = (choice) => {
+            if (typeof choice === "object") {
+                return choice.value || choice;
+            }
+            if (typeof choice === "string") {
+                return choice;
+            }
+            if (typeof choice === "number") {
+                return choices[choice];
+            }
+        };
+        return multiple
+            ? result.userAnswer.map(extractValue)
+            : extractValue(result.userAnswer);
     }
-    promptForDetailedChoice(promptMessage, choices) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inquirerChoices = choices.map((choice) => {
-                return {
-                    title: choice.key,
-                    value: choice.key,
-                    description: choice.description,
-                };
-            });
-            const schema = {
-                message: promptMessage,
-                type: "select",
-                name: "userAnswer",
-                choices: inquirerChoices,
+    async promptForDetailedChoice(promptMessage, choices) {
+        const inquirerChoices = choices.map((choice) => {
+            return {
+                title: choice.key,
+                value: choice.key,
+                description: choice.description,
             };
-            const result = yield this.get([schema]);
-            return result.userAnswer;
         });
+        const schema = {
+            message: promptMessage,
+            type: "select",
+            name: "userAnswer",
+            choices: inquirerChoices,
+        };
+        const result = await this.get([schema]);
+        return result.userAnswer;
     }
-    confirm(message, defaultAction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = {
-                type: "confirm",
-                name: "prompt",
-                default: defaultAction,
-                message,
-            };
-            const result = yield this.get([schema]);
-            return result.prompt;
-        });
+    async confirm(message, defaultAction) {
+        const schema = {
+            type: "confirm",
+            name: "prompt",
+            default: defaultAction,
+            message,
+        };
+        const result = await this.get([schema]);
+        return result.prompt;
     }
     muteStdout() {
         if (helpers.isInteractive()) {

package/lib/common/queue.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.Queue = void 0;
 class Queue {
@@ -21,17 +12,15 @@ class Queue {
             this.promiseResolve();
         }
     }
-    dequeue() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.items.length) {
-                const promise = new Promise((resolve, reject) => {
-                    this.promiseResolve = resolve;
-                });
-                yield promise;
-                this.promiseResolve = null;
-            }
-            return this.items.pop();
-        });
+    async dequeue() {
+        if (!this.items.length) {
+            const promise = new Promise((resolve, reject) => {
+                this.promiseResolve = resolve;
+            });
+            await promise;
+            this.promiseResolve = null;
+        }
+        return this.items.pop();
     }
 }
 exports.Queue = Queue;