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

package/lib/common/bootstrap.js

@@ -95,3 +95,4 @@ yok_1.injector.require("xcodeSelectService", "./services/xcode-select-service");
 yok_1.injector.require("net", "./services/net-service");
 yok_1.injector.require("qr", "./services/qr");
 yok_1.injector.require(["lockfile", "lockService"], "./services/lock-service");
+//# sourceMappingURL=bootstrap.js.map

package/lib/common/child-process.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.ChildProcess = void 0;
 const child_process = require("child_process");
@@ -11,42 +20,47 @@ class ChildProcess extends events_1.EventEmitter {
         this.$logger = $logger;
         this.$errors = $errors;
     }
-    async exec(command, options, execOptions) {
-        return new Promise((resolve, reject) => {
-            const callback = (error, stdout, stderr) => {
-                this.$logger.trace("Exec %s \n stdout: %s \n stderr: %s", command, stdout.toString(), stderr.toString());
-                if (error) {
-                    reject(error);
+    exec(command, options, execOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const callback = (error, stdout, stderr) => {
+                    this.$logger.trace("Exec %s \n stdout: %s \n stderr: %s", command, stdout.toString(), stderr.toString());
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        const output = execOptions && execOptions.showStderr ? { stdout, stderr } : stdout;
+                        resolve(output);
+                    }
+                };
+                if (options) {
+                    child_process.exec(command, options, callback);
                 }
                 else {
-                    const output = execOptions && execOptions.showStderr ? { stdout, stderr } : stdout;
-                    resolve(output);
+                    child_process.exec(command, callback);
                 }
-            };
-            if (options) {
-                child_process.exec(command, options, callback);
-            }
-            else {
-                child_process.exec(command, callback);
-            }
+            });
         });
     }
-    async execFile(command, args) {
-        this.$logger.trace("execFile: %s %s", command, this.getArgumentsAsQuotedString(args));
-        return new Promise((resolve, reject) => {
-            child_process.execFile(command, args, (error, stdout) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve(stdout);
-                }
+    execFile(command, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace("execFile: %s %s", command, this.getArgumentsAsQuotedString(args));
+            return new Promise((resolve, reject) => {
+                child_process.execFile(command, args, (error, stdout) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(stdout);
+                    }
+                });
             });
         });
     }
     spawn(command, args, options) {
         var _a;
         if (command.charAt(0) === ".") {
+            // resolve relative paths to full paths to avoid node Spawn ENOENT errors on some setups.
             const cwd = (_a = options === null || options === void 0 ? void 0 : options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
             command = (0, path_1.resolve)(cwd, command);
         }
@@ -58,6 +72,7 @@ class ChildProcess extends events_1.EventEmitter {
         return child_process.fork(modulePath, args, options);
     }
     spawnFromEvent(command, args, event, options, spawnFromEventOptions) {
+        // event should be exit or close
         return new Promise((resolve, reject) => {
             const childProcess = this.spawn(command, args, options);
             let isResolved = false;
@@ -159,36 +174,42 @@ class ChildProcess extends events_1.EventEmitter {
             });
         });
     }
-    async trySpawnFromCloseEvent(command, args, options, spawnFromEventOptions) {
-        try {
-            const childProcessResult = await this.spawnFromEvent(command, args, "close", options, spawnFromEventOptions);
-            return childProcessResult;
-        }
-        catch (err) {
-            this.$logger.trace(`Error from trySpawnFromCloseEvent method. More info: ${err}`);
-            return Promise.resolve({
-                stderr: err && err.message ? err.message : err,
-                stdout: null,
-                exitCode: -1,
-            });
-        }
+    trySpawnFromCloseEvent(command, args, options, spawnFromEventOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const childProcessResult = yield this.spawnFromEvent(command, args, "close", options, spawnFromEventOptions);
+                return childProcessResult;
+            }
+            catch (err) {
+                this.$logger.trace(`Error from trySpawnFromCloseEvent method. More info: ${err}`);
+                return Promise.resolve({
+                    stderr: err && err.message ? err.message : err,
+                    stdout: null,
+                    exitCode: -1,
+                });
+            }
+        });
     }
-    async tryExecuteApplication(command, args, event, errorMessage, condition) {
-        const childProcess = await this.tryExecuteApplicationCore(command, args, event, errorMessage);
-        if (condition && condition(childProcess)) {
-            this.$errors.fail(errorMessage);
-        }
+    tryExecuteApplication(command, args, event, errorMessage, condition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const childProcess = yield this.tryExecuteApplicationCore(command, args, event, errorMessage);
+            if (condition && condition(childProcess)) {
+                this.$errors.fail(errorMessage);
+            }
+        });
     }
-    async tryExecuteApplicationCore(command, args, event, errorMessage) {
-        try {
-            return this.spawnFromEvent(command, args, event, undefined, {
-                throwError: false,
-            });
-        }
-        catch (e) {
-            const message = e.code === "ENOENT" ? errorMessage : e.message;
-            this.$errors.fail(message);
-        }
+    tryExecuteApplicationCore(command, args, event, errorMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.spawnFromEvent(command, args, event, undefined, {
+                    throwError: false,
+                });
+            }
+            catch (e) {
+                const message = e.code === "ENOENT" ? errorMessage : e.message;
+                this.$errors.fail(message);
+            }
+        });
     }
     getArgumentsAsQuotedString(args) {
         return (args && args.length && args.map((argument) => `"${argument}"`).join(" "));
@@ -196,3 +217,4 @@ class ChildProcess extends events_1.EventEmitter {
 }
 exports.ChildProcess = ChildProcess;
 yok_1.injector.register("childProcess", ChildProcess);
+//# sourceMappingURL=child-process.js.map

package/lib/common/codeGeneration/code-entity.js

@@ -7,7 +7,7 @@ var CodeEntityType;
 (function (CodeEntityType) {
     CodeEntityType[CodeEntityType["Line"] = 0] = "Line";
     CodeEntityType[CodeEntityType["Block"] = 1] = "Block";
-})(CodeEntityType || (exports.CodeEntityType = CodeEntityType = {}));
+})(CodeEntityType = exports.CodeEntityType || (exports.CodeEntityType = {}));
 class Line {
     constructor(content) {
         this.content = content;
@@ -45,3 +45,4 @@ class Block {
 }
 exports.Block = Block;
 yok_1.injector.register("swaggerBlock", Block);
+//# sourceMappingURL=code-entity.js.map

package/lib/common/codeGeneration/code-printer.js

@@ -40,9 +40,10 @@ class CodePrinter {
         return content;
     }
 }
-exports.CodePrinter = CodePrinter;
 CodePrinter.INDENT_CHAR = "\t";
 CodePrinter.NEW_LINE_CHAR = os_1.EOL;
 CodePrinter.START_BLOCK_CHAR = " {";
 CodePrinter.END_BLOCK_CHAR = "}";
+exports.CodePrinter = CodePrinter;
 yok_1.injector.register("swaggerCodePrinter", CodePrinter);
+//# sourceMappingURL=code-printer.js.map

package/lib/common/command-params.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.StringParameterBuilder = exports.StringCommandParameter = void 0;
 const yok_1 = require("./yok");
@@ -7,14 +16,16 @@ class StringCommandParameter {
         this.$injector = $injector;
         this.mandatory = false;
     }
-    async validate(validationValue) {
-        if (!validationValue) {
-            if (this.errorMessage) {
-                this.$injector.resolve("errors").fail(this.errorMessage);
+    validate(validationValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!validationValue) {
+                if (this.errorMessage) {
+                    this.$injector.resolve("errors").fail(this.errorMessage);
+                }
+                return false;
             }
-            return false;
-        }
-        return true;
+            return true;
+        });
     }
 }
 exports.StringCommandParameter = StringCommandParameter;
@@ -32,3 +43,4 @@ class StringParameterBuilder {
 }
 exports.StringParameterBuilder = StringParameterBuilder;
 yok_1.injector.register("stringParameterBuilder", StringParameterBuilder);
+//# sourceMappingURL=command-params.js.map

package/lib/common/commands/analytics.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.ErrorReportingCommand = exports.UsageReportingCommand = exports.AnalyticsCommandParameter = void 0;
 const yok_1 = require("../yok");
@@ -7,17 +16,19 @@ class AnalyticsCommandParameter {
         this.$errors = $errors;
         this.mandatory = false;
     }
-    async validate(validationValue) {
-        const val = validationValue || "";
-        switch (val.toLowerCase()) {
-            case "enable":
-            case "disable":
-            case "status":
-            case "":
-                return true;
-            default:
-                this.$errors.failWithHelp(`The value '${validationValue}' is not valid. Valid values are 'enable', 'disable' and 'status'.`);
-        }
+    validate(validationValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const val = validationValue || "";
+            switch (val.toLowerCase()) {
+                case "enable":
+                case "disable":
+                case "status":
+                case "":
+                    return true;
+                default:
+                    this.$errors.failWithHelp(`The value '${validationValue}' is not valid. Valid values are 'enable', 'disable' and 'status'.`);
+            }
+        });
     }
 }
 exports.AnalyticsCommandParameter = AnalyticsCommandParameter;
@@ -32,22 +43,26 @@ class AnalyticsCommand {
         this.allowedParameters = [new AnalyticsCommandParameter(this.$errors)];
         this.disableAnalytics = true;
     }
-    async execute(args) {
-        const arg = args[0] || "";
-        switch (arg.toLowerCase()) {
-            case "enable":
-                await this.$analyticsService.setStatus(this.settingName, true);
-                this.$logger.info(`${this.humanReadableSettingName} is now enabled.`);
-                break;
-            case "disable":
-                await this.$analyticsService.setStatus(this.settingName, false);
-                this.$logger.info(`${this.humanReadableSettingName} is now disabled.`);
-                break;
-            case "status":
-            case "":
-                this.$logger.info(await this.$analyticsService.getStatusMessage(this.settingName, this.$options.json, this.humanReadableSettingName));
-                break;
-        }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const arg = args[0] || "";
+            switch (arg.toLowerCase()) {
+                case "enable":
+                    yield this.$analyticsService.setStatus(this.settingName, true);
+                    // TODO(Analytics): await this.$analyticsService.track(this.settingName, "enabled");
+                    this.$logger.info(`${this.humanReadableSettingName} is now enabled.`);
+                    break;
+                case "disable":
+                    // TODO(Analytics): await this.$analyticsService.track(this.settingName, "disabled");
+                    yield this.$analyticsService.setStatus(this.settingName, false);
+                    this.$logger.info(`${this.humanReadableSettingName} is now disabled.`);
+                    break;
+                case "status":
+                case "":
+                    this.$logger.info(yield this.$analyticsService.getStatusMessage(this.settingName, this.$options.json, this.humanReadableSettingName));
+                    break;
+            }
+        });
     }
 }
 class UsageReportingCommand extends AnalyticsCommand {
@@ -66,3 +81,4 @@ class ErrorReportingCommand extends AnalyticsCommand {
 }
 exports.ErrorReportingCommand = ErrorReportingCommand;
 yok_1.injector.registerCommand("error-reporting", ErrorReportingCommand);
+//# sourceMappingURL=analytics.js.map

package/lib/common/commands/autocompletion.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.AutoCompleteStatusCommand = exports.EnableAutoCompleteCommand = exports.DisableAutoCompleteCommand = exports.AutoCompleteCommand = void 0;
 const helpers = require("../helpers");
@@ -11,28 +20,32 @@ class AutoCompleteCommand {
         this.disableAnalytics = true;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        if (helpers.isInteractive()) {
-            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
-                if (this.$autoCompletionService.isObsoleteAutoCompletionEnabled()) {
-                    await this.$autoCompletionService.enableAutoCompletion();
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (helpers.isInteractive()) {
+                if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                    if (this.$autoCompletionService.isObsoleteAutoCompletionEnabled()) {
+                        // obsolete autocompletion is enabled, update it to the new one:
+                        yield this.$autoCompletionService.enableAutoCompletion();
+                    }
+                    else {
+                        this.$logger.info("Autocompletion is already enabled");
+                    }
                 }
                 else {
-                    this.$logger.info("Autocompletion is already enabled");
+                    this.$logger.info("If you are using bash or zsh, you can enable command-line completion.");
+                    const message = "Do you want to enable it now?";
+                    const autoCompetionStatus = yield this.$prompter.confirm(message, () => true);
+                    if (autoCompetionStatus) {
+                        yield this.$autoCompletionService.enableAutoCompletion();
+                    }
+                    else {
+                        // make sure we've removed all autocompletion code from all shell profiles
+                        this.$autoCompletionService.disableAutoCompletion();
+                    }
                 }
             }
-            else {
-                this.$logger.info("If you are using bash or zsh, you can enable command-line completion.");
-                const message = "Do you want to enable it now?";
-                const autoCompetionStatus = await this.$prompter.confirm(message, () => true);
-                if (autoCompetionStatus) {
-                    await this.$autoCompletionService.enableAutoCompletion();
-                }
-                else {
-                    this.$autoCompletionService.disableAutoCompletion();
-                }
-            }
-        }
+        });
     }
 }
 exports.AutoCompleteCommand = AutoCompleteCommand;
@@ -44,13 +57,15 @@ class DisableAutoCompleteCommand {
         this.disableAnalytics = true;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        if (this.$autoCompletionService.isAutoCompletionEnabled()) {
-            this.$autoCompletionService.disableAutoCompletion();
-        }
-        else {
-            this.$logger.info("Autocompletion is already disabled.");
-        }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                this.$autoCompletionService.disableAutoCompletion();
+            }
+            else {
+                this.$logger.info("Autocompletion is already disabled.");
+            }
+        });
     }
 }
 exports.DisableAutoCompleteCommand = DisableAutoCompleteCommand;
@@ -62,13 +77,15 @@ class EnableAutoCompleteCommand {
         this.disableAnalytics = true;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        if (this.$autoCompletionService.isAutoCompletionEnabled()) {
-            this.$logger.info("Autocompletion is already enabled.");
-        }
-        else {
-            await this.$autoCompletionService.enableAutoCompletion();
-        }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                this.$logger.info("Autocompletion is already enabled.");
+            }
+            else {
+                yield this.$autoCompletionService.enableAutoCompletion();
+            }
+        });
     }
 }
 exports.EnableAutoCompleteCommand = EnableAutoCompleteCommand;
@@ -80,14 +97,17 @@ class AutoCompleteStatusCommand {
         this.disableAnalytics = true;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        if (this.$autoCompletionService.isAutoCompletionEnabled()) {
-            this.$logger.info("Autocompletion is enabled.");
-        }
-        else {
-            this.$logger.info("Autocompletion is disabled.");
-        }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                this.$logger.info("Autocompletion is enabled.");
+            }
+            else {
+                this.$logger.info("Autocompletion is disabled.");
+            }
+        });
     }
 }
 exports.AutoCompleteStatusCommand = AutoCompleteStatusCommand;
 yok_1.injector.registerCommand("autocomplete|status", AutoCompleteStatusCommand);
+//# sourceMappingURL=autocompletion.js.map

package/lib/common/commands/device/device-log-stream.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.OpenDeviceLogStreamCommand = void 0;
 const yok_1 = require("../../yok");
@@ -14,20 +23,23 @@ class OpenDeviceLogStreamCommand {
         $iOSSimulatorLogProvider.setShouldDispose(false);
         $cleanupService.setShouldDispose(false);
     }
-    async execute(args) {
-        this.$deviceLogProvider.setLogLevel(this.$loggingLevels.full);
-        await this.$devicesService.initialize({
-            deviceId: this.$options.device,
-            skipInferPlatform: true,
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$deviceLogProvider.setLogLevel(this.$loggingLevels.full);
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            if (this.$devicesService.deviceCount > 1) {
+                yield this.$commandsService.tryExecuteCommand("device", []);
+                this.$errors.failWithHelp(OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE);
+            }
+            const action = (device) => device.openDeviceLogStream();
+            yield this.$devicesService.execute(action);
         });
-        if (this.$devicesService.deviceCount > 1) {
-            await this.$commandsService.tryExecuteCommand("device", []);
-            this.$errors.failWithHelp(OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE);
-        }
-        const action = (device) => device.openDeviceLogStream();
-        await this.$devicesService.execute(action);
     }
 }
-exports.OpenDeviceLogStreamCommand = OpenDeviceLogStreamCommand;
 OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE = "More than one device found. Specify device explicitly.";
+exports.OpenDeviceLogStreamCommand = OpenDeviceLogStreamCommand;
 yok_1.injector.registerCommand(["device|log", "devices|log"], OpenDeviceLogStreamCommand);
+//# sourceMappingURL=device-log-stream.js.map

package/lib/common/commands/device/get-file.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.GetFileCommand = void 0;
 const yok_1 = require("../../yok");
@@ -14,30 +23,34 @@ class GetFileCommand {
             this.$stringParameter,
         ];
     }
-    async execute(args) {
-        await this.$devicesService.initialize({
-            deviceId: this.$options.device,
-            skipInferPlatform: true,
-        });
-        let appIdentifier = args[1];
-        if (!appIdentifier) {
-            try {
-                this.$projectData.initializeProjectData();
-            }
-            catch (err) {
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            let appIdentifier = args[1];
+            if (!appIdentifier) {
+                try {
+                    this.$projectData.initializeProjectData();
+                }
+                catch (err) {
+                    // ignore the error
+                }
+                if (!this.$projectData.projectIdentifiers) {
+                    this.$errors.fail("Please enter application identifier or execute this command in project.");
+                }
             }
-            if (!this.$projectData.projectIdentifiers) {
-                this.$errors.fail("Please enter application identifier or execute this command in project.");
-            }
-        }
-        const action = async (device) => {
-            appIdentifier =
-                appIdentifier ||
-                    this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()];
-            await device.fileSystem.getFile(args[0], appIdentifier, this.$options.file);
-        };
-        await this.$devicesService.execute(action);
+            const action = (device) => __awaiter(this, void 0, void 0, function* () {
+                appIdentifier =
+                    appIdentifier ||
+                        this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()];
+                yield device.fileSystem.getFile(args[0], appIdentifier, this.$options.file);
+            });
+            yield this.$devicesService.execute(action);
+        });
     }
 }
 exports.GetFileCommand = GetFileCommand;
 yok_1.injector.registerCommand(["device|get-file", "devices|get-file"], GetFileCommand);
+//# sourceMappingURL=get-file.js.map

package/lib/common/commands/device/list-applications.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.ListApplicationsCommand = void 0;
 const os_1 = require("os");
@@ -12,20 +21,23 @@ class ListApplicationsCommand {
         this.$options = $options;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        await this.$devicesService.initialize({
-            deviceId: this.$options.device,
-            skipInferPlatform: true,
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            const output = [];
+            const action = (device) => __awaiter(this, void 0, void 0, function* () {
+                const applications = yield device.applicationManager.getInstalledApplications();
+                output.push(util.format("%s=====Installed applications on device with UDID '%s' are:", os_1.EOL, device.deviceInfo.identifier));
+                _.each(applications, (applicationId) => output.push(applicationId));
+            });
+            yield this.$devicesService.execute(action);
+            this.$logger.info(output.join(os_1.EOL));
         });
-        const output = [];
-        const action = async (device) => {
-            const applications = await device.applicationManager.getInstalledApplications();
-            output.push(util.format("%s=====Installed applications on device with UDID '%s' are:", os_1.EOL, device.deviceInfo.identifier));
-            _.each(applications, (applicationId) => output.push(applicationId));
-        };
-        await this.$devicesService.execute(action);
-        this.$logger.info(output.join(os_1.EOL));
     }
 }
 exports.ListApplicationsCommand = ListApplicationsCommand;
 yok_1.injector.registerCommand(["device|list-applications", "devices|list-applications"], ListApplicationsCommand);
+//# sourceMappingURL=list-applications.js.map