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

package/lib/commands/debug.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.DebugAndroidCommand = exports.DebugIOSCommand = exports.DebugPlatformCommand = void 0;
 const decorators_1 = require("../common/decorators");
@@ -36,56 +27,49 @@ class DebugPlatformCommand extends command_base_1.ValidatePlatformCommandBase {
         this.allowedParameters = [];
         $cleanupService.setShouldDispose(false);
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$devicesService.initialize({
-                platform: this.platform,
-                deviceId: this.$options.device,
-                emulator: this.$options.emulator,
-                skipDeviceDetectionInterval: true,
-            });
-            const selectedDeviceForDebug = yield this.$devicesService.pickSingleDevice({
-                onlyEmulators: this.$options.emulator,
-                onlyDevices: this.$options.forDevice,
-                deviceId: this.$options.device,
-            });
-            if (this.$options.start) {
-                const debugOptions = _.cloneDeep(this.$options.argv);
-                const debugData = this.$debugDataService.getDebugData(selectedDeviceForDebug.deviceInfo.identifier, this.$projectData, debugOptions);
-                yield this.$debugController.printDebugInformation(yield this.$debugController.startDebug(debugData));
-                return;
-            }
-            yield this.$liveSyncCommandHelper.executeLiveSyncOperation([selectedDeviceForDebug], this.platform, {
-                deviceDebugMap: {
-                    [selectedDeviceForDebug.deviceInfo.identifier]: true,
-                },
-                buildPlatform: undefined,
-                skipNativePrepare: false,
-            });
+    async execute(args) {
+        await this.$devicesService.initialize({
+            platform: this.platform,
+            deviceId: this.$options.device,
+            emulator: this.$options.emulator,
+            skipDeviceDetectionInterval: true,
         });
-    }
-    canExecute(args) {
-        const _super = Object.create(null, {
-            canExecuteCommandBase: { get: () => super.canExecuteCommandBase }
+        const selectedDeviceForDebug = await this.$devicesService.pickSingleDevice({
+            onlyEmulators: this.$options.emulator,
+            onlyDevices: this.$options.forDevice,
+            deviceId: this.$options.device,
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$options.force) {
-                yield this.$migrateController.validate({
-                    projectDir: this.$projectData.projectDir,
-                    platforms: [this.platform],
-                });
-            }
-            if (!this.$platformValidationService.isPlatformSupportedForOS(this.platform, this.$projectData)) {
-                this.$errors.fail(`Applications for platform ${this.platform} can not be built on this OS`);
-            }
-            if (this.$options.release) {
-                this.$errors.failWithHelp("--release flag is not applicable to this command.");
-            }
-            const result = yield _super.canExecuteCommandBase.call(this, this.platform, {
-                validateOptions: true,
+        if (this.$options.start) {
+            const debugOptions = _.cloneDeep(this.$options.argv);
+            const debugData = this.$debugDataService.getDebugData(selectedDeviceForDebug.deviceInfo.identifier, this.$projectData, debugOptions);
+            await this.$debugController.printDebugInformation(await this.$debugController.startDebug(debugData));
+            return;
+        }
+        await this.$liveSyncCommandHelper.executeLiveSyncOperation([selectedDeviceForDebug], this.platform, {
+            deviceDebugMap: {
+                [selectedDeviceForDebug.deviceInfo.identifier]: true,
+            },
+            buildPlatform: undefined,
+            skipNativePrepare: false,
+        });
+    }
+    async canExecute(args) {
+        if (!this.$options.force) {
+            await this.$migrateController.validate({
+                projectDir: this.$projectData.projectDir,
+                platforms: [this.platform],
             });
-            return result;
+        }
+        if (!this.$platformValidationService.isPlatformSupportedForOS(this.platform, this.$projectData)) {
+            this.$errors.fail(`Applications for platform ${this.platform} can not be built on this OS`);
+        }
+        if (this.$options.release) {
+            this.$errors.failWithHelp("--release flag is not applicable to this command.");
+        }
+        const result = await super.canExecuteCommandBase(this.platform, {
+            validateOptions: true,
         });
+        return result;
     }
 }
 exports.DebugPlatformCommand = DebugPlatformCommand;
@@ -106,35 +90,29 @@ class DebugIOSCommand {
         this.allowedParameters = [];
         this.platform = this.$devicePlatformsConstants.iOS;
         this.$projectData.initializeProjectData();
-        // Do not dispose ios-device-lib, so the process will remain alive and the debug application (NativeScript Inspector or Chrome DevTools) will be able to connect to the socket.
-        // In case we dispose ios-device-lib, the socket will be closed and the code will fail when the debug application tries to read/send data to device socket.
-        // That's why the `$ tns debug ios --justlaunch` command will not release the terminal.
-        // In case we do not set it to false, the dispose will be called once the command finishes its execution, which will prevent the debugging.
         $iosDeviceOperations.setShouldDispose(false);
         $iOSSimulatorLogProvider.setShouldDispose(false);
     }
     execute(args) {
         return this.debugPlatformCommand.execute(args);
     }
-    canExecute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$platformValidationService.isPlatformSupportedForOS(this.$devicePlatformsConstants.iOS, this.$projectData)) {
-                this.$errors.fail(`Applications for platform ${this.$devicePlatformsConstants.iOS} can not be built on this OS`);
-            }
-            const isValidTimeoutOption = this.isValidTimeoutOption();
-            if (!isValidTimeoutOption) {
-                this.$errors.fail(`Timeout option specifies the seconds NativeScript CLI will wait to find the inspector socket port from device's logs. Must be a number.`);
-            }
-            if (this.$options.inspector) {
-                const macOSWarning = yield this.$sysInfo.getMacOSWarningMessage();
-                if (macOSWarning &&
-                    macOSWarning.severity === "high" /* SystemWarningsSeverity.high */) {
-                    this.$errors.fail(`You cannot use NativeScript Inspector on this OS. To use it, please update your OS.`);
-                }
+    async canExecute(args) {
+        if (!this.$platformValidationService.isPlatformSupportedForOS(this.$devicePlatformsConstants.iOS, this.$projectData)) {
+            this.$errors.fail(`Applications for platform ${this.$devicePlatformsConstants.iOS} can not be built on this OS`);
+        }
+        const isValidTimeoutOption = this.isValidTimeoutOption();
+        if (!isValidTimeoutOption) {
+            this.$errors.fail(`Timeout option specifies the seconds NativeScript CLI will wait to find the inspector socket port from device's logs. Must be a number.`);
+        }
+        if (this.$options.inspector) {
+            const macOSWarning = await this.$sysInfo.getMacOSWarningMessage();
+            if (macOSWarning &&
+                macOSWarning.severity === "high") {
+                this.$errors.fail(`You cannot use NativeScript Inspector on this OS. To use it, please update your OS.`);
             }
-            const result = yield this.debugPlatformCommand.canExecute(args);
-            return result;
-        });
+        }
+        const result = await this.debugPlatformCommand.canExecute(args);
+        return result;
     }
     isValidTimeoutOption() {
         if (!this.$options.timeout) {
@@ -150,10 +128,10 @@ class DebugIOSCommand {
         return true;
     }
 }
+exports.DebugIOSCommand = DebugIOSCommand;
 __decorate([
     (0, decorators_1.cache)()
 ], DebugIOSCommand.prototype, "debugPlatformCommand", null);
-exports.DebugIOSCommand = DebugIOSCommand;
 yok_1.injector.registerCommand("debug|ios", DebugIOSCommand);
 class DebugAndroidCommand {
     get debugPlatformCommand() {
@@ -171,26 +149,21 @@ class DebugAndroidCommand {
         this.platform = this.$devicePlatformsConstants.Android;
         this.$projectData.initializeProjectData();
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.debugPlatformCommand.execute(args);
-        });
+    async execute(args) {
+        return this.debugPlatformCommand.execute(args);
     }
-    canExecute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const canExecuteBase = yield this.debugPlatformCommand.canExecute(args);
-            if (canExecuteBase) {
-                if (this.$options.aab && !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
-                    this.$errors.failWithHelp(constants_1.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
-                }
+    async canExecute(args) {
+        const canExecuteBase = await this.debugPlatformCommand.canExecute(args);
+        if (canExecuteBase) {
+            if (this.$options.aab && !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
+                this.$errors.failWithHelp(constants_1.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
             }
-            return canExecuteBase;
-        });
+        }
+        return canExecuteBase;
     }
 }
+exports.DebugAndroidCommand = DebugAndroidCommand;
 __decorate([
     (0, decorators_1.cache)()
 ], DebugAndroidCommand.prototype, "debugPlatformCommand", null);
-exports.DebugAndroidCommand = DebugAndroidCommand;
 yok_1.injector.registerCommand("debug|android", DebugAndroidCommand);
-//# sourceMappingURL=debug.js.map

package/lib/commands/deploy.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.DeployOnDeviceCommand = void 0;
 const constants_1 = require("../constants");
@@ -25,55 +16,47 @@ class DeployOnDeviceCommand extends command_base_1.ValidatePlatformCommandBase {
         this.allowedParameters = [];
         this.dashedOptions = {
             watch: {
-                type: "boolean" /* OptionType.Boolean */,
+                type: "boolean",
                 default: false,
                 hasSensitiveValue: false,
             },
-            hmr: { type: "boolean" /* OptionType.Boolean */, default: false, hasSensitiveValue: false },
+            hmr: { type: "boolean", default: false, hasSensitiveValue: false },
         };
         this.$projectData.initializeProjectData();
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const platform = args[0];
-            yield this.$deployCommandHelper.deploy(platform);
-        });
+    async execute(args) {
+        const platform = args[0];
+        await this.$deployCommandHelper.deploy(platform);
     }
-    canExecute(args) {
-        const _super = Object.create(null, {
-            canExecuteCommandBase: { get: () => super.canExecuteCommandBase }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const platform = args[0];
-            if (!this.$options.force) {
-                yield this.$migrateController.validate({
-                    projectDir: this.$projectData.projectDir,
-                    platforms: [platform],
-                });
-            }
-            if (!args || !args.length || args.length > 1) {
-                return false;
-            }
-            if (!(yield this.$platformCommandParameter.validate(platform))) {
-                return false;
+    async canExecute(args) {
+        const platform = args[0];
+        if (!this.$options.force) {
+            await this.$migrateController.validate({
+                projectDir: this.$projectData.projectDir,
+                platforms: [platform],
+            });
+        }
+        if (!args || !args.length || args.length > 1) {
+            return false;
+        }
+        if (!(await this.$platformCommandParameter.validate(platform))) {
+            return false;
+        }
+        if (this.$mobileHelper.isAndroidPlatform(platform) &&
+            (this.$options.release || this.$options.aab) &&
+            !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
+            if (this.$options.release) {
+                this.$errors.failWithHelp(constants_1.ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
             }
-            if (this.$mobileHelper.isAndroidPlatform(platform) &&
-                (this.$options.release || this.$options.aab) &&
-                !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
-                if (this.$options.release) {
-                    this.$errors.failWithHelp(constants_1.ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
-                }
-                else {
-                    this.$errors.failWithHelp(constants_1.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
-                }
+            else {
+                this.$errors.failWithHelp(constants_1.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
             }
-            const result = yield _super.canExecuteCommandBase.call(this, platform, {
-                validateOptions: true,
-            });
-            return result;
+        }
+        const result = await super.canExecuteCommandBase(platform, {
+            validateOptions: true,
         });
+        return result;
     }
 }
 exports.DeployOnDeviceCommand = DeployOnDeviceCommand;
 yok_1.injector.registerCommand("deploy", DeployOnDeviceCommand);
-//# sourceMappingURL=deploy.js.map

package/lib/commands/embedding/embed.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.EmbedCommand = void 0;
 const yok_1 = require("../../common/yok");
@@ -31,68 +22,51 @@ class EmbedCommand extends prepare_1.PrepareCommand {
     }
     resolveHostProjectPath(hostProjectPath) {
         if (hostProjectPath.charAt(0) === ".") {
-            // resolve relative to the project dir
             const projectDir = this.$projectData.projectDir;
             return (0, path_1.resolve)(projectDir, hostProjectPath);
         }
         return (0, path_1.resolve)(hostProjectPath);
     }
-    execute(args) {
-        const _super = Object.create(null, {
-            execute: { get: () => super.execute }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const hostProjectPath = args[1];
-            const resolvedHostProjectPath = this.resolveHostProjectPath(hostProjectPath);
-            if (!this.$fs.exists(resolvedHostProjectPath)) {
-                this.$logger.error(`The host project path ${color_1.color.yellow(hostProjectPath)} (resolved to: ${color_1.color.yellow.dim(resolvedHostProjectPath)}) does not exist.`);
-                return;
-            }
-            this.$options["hostProjectPath"] = resolvedHostProjectPath;
-            if (args.length > 2) {
-                this.$options["hostProjectModuleName"] = args[2];
-            }
-            return _super.execute.call(this, args);
-        });
+    async execute(args) {
+        const hostProjectPath = args[1];
+        const resolvedHostProjectPath = this.resolveHostProjectPath(hostProjectPath);
+        if (!this.$fs.exists(resolvedHostProjectPath)) {
+            this.$logger.error(`The host project path ${color_1.color.yellow(hostProjectPath)} (resolved to: ${color_1.color.yellow.dim(resolvedHostProjectPath)}) does not exist.`);
+            return;
+        }
+        this.$options["hostProjectPath"] = resolvedHostProjectPath;
+        if (args.length > 2) {
+            this.$options["hostProjectModuleName"] = args[2];
+        }
+        return super.execute(args);
     }
-    canExecute(args) {
-        const _super = Object.create(null, {
-            canExecute: { get: () => super.canExecute }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const canSuperExecute = yield _super.canExecute.call(this, args);
-            if (!canSuperExecute) {
-                return false;
-            }
-            // args[0] is the platform
-            // args[1] is the path to the host project
-            // args[2] is the host project module name
-            const platform = args[0].toLowerCase();
-            // also allow these to be set in the nativescript.config.ts
-            if (!args[1]) {
-                const hostProjectPath = this.getEmbedConfigForKey("hostProjectPath", platform);
-                if (hostProjectPath) {
-                    args[1] = hostProjectPath;
-                }
-            }
-            if (!args[2]) {
-                const hostProjectModuleName = this.getEmbedConfigForKey("hostProjectModuleName", platform);
-                if (hostProjectModuleName) {
-                    args[2] = hostProjectModuleName;
-                }
+    async canExecute(args) {
+        const canSuperExecute = await super.canExecute(args);
+        if (!canSuperExecute) {
+            return false;
+        }
+        const platform = args[0].toLowerCase();
+        if (!args[1]) {
+            const hostProjectPath = this.getEmbedConfigForKey("hostProjectPath", platform);
+            if (hostProjectPath) {
+                args[1] = hostProjectPath;
             }
-            console.log(args);
-            if (args.length < 2) {
-                return false;
+        }
+        if (!args[2]) {
+            const hostProjectModuleName = this.getEmbedConfigForKey("hostProjectModuleName", platform);
+            if (hostProjectModuleName) {
+                args[2] = hostProjectModuleName;
             }
-            return true;
-        });
+        }
+        console.log(args);
+        if (args.length < 2) {
+            return false;
+        }
+        return true;
     }
     getEmbedConfigForKey(key, platform) {
-        // get the embed.<platform>.<key> value, or fallback to embed.<key> value
         return this.$projectConfigService.getValue(`embed.${platform}.${key}`, this.$projectConfigService.getValue(`embed.${key}`));
     }
 }
 exports.EmbedCommand = EmbedCommand;
 yok_1.injector.registerCommand("embed", EmbedCommand);
-//# sourceMappingURL=embed.js.map

package/lib/commands/extensibility/install-extension.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.InstallExtensionCommand = void 0;
 const yok_1 = require("../../common/yok");
@@ -20,15 +11,12 @@ class InstallExtensionCommand {
             this.$stringParameterBuilder.createMandatoryParameter("You have to provide a valid name for extension that you want to install."),
         ];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const extensionData = yield this.$extensibilityService.installExtension(args[0]);
-            this.$logger.info(`Successfully installed extension ${extensionData.extensionName}.`);
-            yield this.$extensibilityService.loadExtension(extensionData.extensionName);
-            this.$logger.info(`Successfully loaded extension ${extensionData.extensionName}.`);
-        });
+    async execute(args) {
+        const extensionData = await this.$extensibilityService.installExtension(args[0]);
+        this.$logger.info(`Successfully installed extension ${extensionData.extensionName}.`);
+        await this.$extensibilityService.loadExtension(extensionData.extensionName);
+        this.$logger.info(`Successfully loaded extension ${extensionData.extensionName}.`);
     }
 }
 exports.InstallExtensionCommand = InstallExtensionCommand;
 yok_1.injector.registerCommand("extension|install", InstallExtensionCommand);
-//# sourceMappingURL=install-extension.js.map

package/lib/commands/extensibility/list-extensions.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.ListExtensionsCommand = void 0;
 const _ = require("lodash");
@@ -19,23 +10,20 @@ class ListExtensionsCommand {
         this.$logger = $logger;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const installedExtensions = this.$extensibilityService.getInstalledExtensions();
-            if (_.keys(installedExtensions).length) {
-                this.$logger.info("Installed extensions:");
-                const data = _.map(installedExtensions, (version, name) => {
-                    return [name, version];
-                });
-                const table = helpers.createTable(["Name", "Version"], data);
-                this.$logger.info(table.toString());
-            }
-            else {
-                this.$logger.info("No extensions installed.");
-            }
-        });
+    async execute(args) {
+        const installedExtensions = this.$extensibilityService.getInstalledExtensions();
+        if (_.keys(installedExtensions).length) {
+            this.$logger.info("Installed extensions:");
+            const data = _.map(installedExtensions, (version, name) => {
+                return [name, version];
+            });
+            const table = helpers.createTable(["Name", "Version"], data);
+            this.$logger.info(table.toString());
+        }
+        else {
+            this.$logger.info("No extensions installed.");
+        }
     }
 }
 exports.ListExtensionsCommand = ListExtensionsCommand;
 yok_1.injector.registerCommand("extension|*list", ListExtensionsCommand);
-//# sourceMappingURL=list-extensions.js.map

package/lib/commands/extensibility/uninstall-extension.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.UninstallExtensionCommand = void 0;
 const yok_1 = require("../../common/yok");
@@ -20,14 +11,11 @@ class UninstallExtensionCommand {
             this.$stringParameterBuilder.createMandatoryParameter("You have to provide a valid name for extension that you want to uninstall."),
         ];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const extensionName = args[0];
-            yield this.$extensibilityService.uninstallExtension(extensionName);
-            this.$logger.info(`Successfully uninstalled extension ${extensionName}`);
-        });
+    async execute(args) {
+        const extensionName = args[0];
+        await this.$extensibilityService.uninstallExtension(extensionName);
+        this.$logger.info(`Successfully uninstalled extension ${extensionName}`);
     }
 }
 exports.UninstallExtensionCommand = UninstallExtensionCommand;
 yok_1.injector.registerCommand("extension|uninstall", UninstallExtensionCommand);
-//# sourceMappingURL=uninstall-extension.js.map

package/lib/commands/fonts.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.FontsCommand = void 0;
 const yok_1 = require("../common/yok");
@@ -24,42 +15,39 @@ class FontsCommand {
         this.allowedParameters = [];
         this.$projectData.initializeProjectData();
     }
-    execute(args) {
+    async execute(args) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const supportedExtensions = [".ttf", ".otf"];
-            const defaultFontsFolderPaths = [
-                path.join((_a = this.$projectConfigService.getValue("appPath")) !== null && _a !== void 0 ? _a : "", constants.FONTS_DIR),
-                path.join(constants.APP_FOLDER_NAME, constants.FONTS_DIR),
-                path.join(constants.SRC_DIR, constants.FONTS_DIR),
-            ].map((entry) => path.resolve(this.$projectData.projectDir, entry));
-            const fontsFolderPath = defaultFontsFolderPaths.find((entry) => this.$fs.exists(entry));
-            if (!fontsFolderPath) {
-                this.$logger.warn("No fonts folder found.");
-                return;
-            }
-            const files = this.$fs
-                .readDirectory(fontsFolderPath)
-                .map((entry) => path.parse(entry))
-                .filter((entry) => {
-                return supportedExtensions.includes(entry.ext);
-            });
-            if (!files.length) {
-                this.$logger.warn("No custom fonts found.");
-                return;
-            }
-            const table = (0, helpers_1.createTable)(["Font", "CSS Properties"], []);
-            for (const file of files) {
-                const font = yield fontFinder.get(fontsFolderPath + "/" + file.base);
-                table.push([
-                    file.base,
-                    `font-family: "${font.name}", "${file.name}"; font-weight: ${font.weight};`,
-                ]);
-            }
-            this.$logger.info(table.toString());
+        const supportedExtensions = [".ttf", ".otf"];
+        const defaultFontsFolderPaths = [
+            path.join((_a = this.$projectConfigService.getValue("appPath")) !== null && _a !== void 0 ? _a : "", constants.FONTS_DIR),
+            path.join(constants.APP_FOLDER_NAME, constants.FONTS_DIR),
+            path.join(constants.SRC_DIR, constants.FONTS_DIR),
+        ].map((entry) => path.resolve(this.$projectData.projectDir, entry));
+        const fontsFolderPath = defaultFontsFolderPaths.find((entry) => this.$fs.exists(entry));
+        if (!fontsFolderPath) {
+            this.$logger.warn("No fonts folder found.");
+            return;
+        }
+        const files = this.$fs
+            .readDirectory(fontsFolderPath)
+            .map((entry) => path.parse(entry))
+            .filter((entry) => {
+            return supportedExtensions.includes(entry.ext);
         });
+        if (!files.length) {
+            this.$logger.warn("No custom fonts found.");
+            return;
+        }
+        const table = (0, helpers_1.createTable)(["Font", "CSS Properties"], []);
+        for (const file of files) {
+            const font = await fontFinder.get(fontsFolderPath + "/" + file.base);
+            table.push([
+                file.base,
+                `font-family: "${font.name}", "${file.name}"; font-weight: ${font.weight};`,
+            ]);
+        }
+        this.$logger.info(table.toString());
     }
 }
 exports.FontsCommand = FontsCommand;
 yok_1.injector.registerCommand("fonts", FontsCommand);
-//# sourceMappingURL=fonts.js.map