nativescript 8.9.0-dev.0 → 8.9.0-dev.2

package/lib/commands/plugin/update-plugin.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.UpdatePluginCommand = void 0;
 const _ = require("lodash");
@@ -11,29 +20,34 @@ class UpdatePluginCommand {
         this.allowedParameters = [];
         this.$projectData.initializeProjectData();
     }
-    async execute(args) {
-        let pluginNames = args;
-        if (!pluginNames || args.length === 0) {
-            const installedPlugins = await this.$pluginsService.getAllInstalledPlugins(this.$projectData);
-            pluginNames = installedPlugins.map((p) => p.name);
-        }
-        for (const pluginName of pluginNames) {
-            await this.$pluginsService.remove(pluginName, this.$projectData);
-            await this.$pluginsService.add(pluginName, this.$projectData);
-        }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let pluginNames = args;
+            if (!pluginNames || args.length === 0) {
+                const installedPlugins = yield this.$pluginsService.getAllInstalledPlugins(this.$projectData);
+                pluginNames = installedPlugins.map((p) => p.name);
+            }
+            for (const pluginName of pluginNames) {
+                yield this.$pluginsService.remove(pluginName, this.$projectData);
+                yield this.$pluginsService.add(pluginName, this.$projectData);
+            }
+        });
     }
-    async canExecute(args) {
-        if (!args || args.length === 0) {
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args || args.length === 0) {
+                return true;
+            }
+            const installedPlugins = yield this.$pluginsService.getAllInstalledPlugins(this.$projectData);
+            const installedPluginNames = installedPlugins.map((pl) => pl.name);
+            const pluginName = args[0].toLowerCase();
+            if (!_.some(installedPluginNames, (name) => name.toLowerCase() === pluginName)) {
+                this.$errors.fail(`Plugin "${pluginName}" is not installed.`);
+            }
             return true;
-        }
-        const installedPlugins = await this.$pluginsService.getAllInstalledPlugins(this.$projectData);
-        const installedPluginNames = installedPlugins.map((pl) => pl.name);
-        const pluginName = args[0].toLowerCase();
-        if (!_.some(installedPluginNames, (name) => name.toLowerCase() === pluginName)) {
-            this.$errors.fail(`Plugin "${pluginName}" is not installed.`);
-        }
-        return true;
+        });
     }
 }
 exports.UpdatePluginCommand = UpdatePluginCommand;
 yok_1.injector.registerCommand("plugin|update", UpdatePluginCommand);
+//# sourceMappingURL=update-plugin.js.map

package/lib/commands/post-install.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.PostInstallCliCommand = void 0;
 const helpers_1 = require("../common/helpers");
@@ -16,29 +25,39 @@ class PostInstallCliCommand {
         this.disableAnalytics = true;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        const isRunningWithSudoUser = !!process.env.SUDO_USER;
-        if (!this.$hostInfo.isWindows) {
-            if (isRunningWithSudoUser) {
-                await this.$fs.setCurrentUserAsOwner(this.$settingsService.getProfileDir(), process.env.SUDO_USER);
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isRunningWithSudoUser = !!process.env.SUDO_USER;
+            if (!this.$hostInfo.isWindows) {
+                // when running under 'sudo' we create a working dir with wrong owner (root) and
+                // it is no longer accessible for the user initiating the installation
+                // patch the owner here
+                if (isRunningWithSudoUser) {
+                    // TODO: Check if this is the correct place, probably we should set this at the end of the command.
+                    yield this.$fs.setCurrentUserAsOwner(this.$settingsService.getProfileDir(), process.env.SUDO_USER);
+                }
             }
-        }
-        const canExecutePostInstallTask = !isRunningWithSudoUser || (0, helpers_1.doesCurrentNpmCommandMatch)([/^--unsafe-perm$/]);
-        if (canExecutePostInstallTask) {
-            await this.$helpService.generateHtmlPages();
-            await this.$analyticsService.checkConsent();
-            await this.$commandsService.tryExecuteCommand("autocomplete", []);
-        }
+            const canExecutePostInstallTask = !isRunningWithSudoUser || (0, helpers_1.doesCurrentNpmCommandMatch)([/^--unsafe-perm$/]);
+            if (canExecutePostInstallTask) {
+                yield this.$helpService.generateHtmlPages();
+                // Explicitly ask for confirmation of usage-reporting:
+                yield this.$analyticsService.checkConsent();
+                yield this.$commandsService.tryExecuteCommand("autocomplete", []);
+            }
+        });
     }
-    async postCommandAction(args) {
-        this.$logger.info("");
-        this.$logger.info(color_1.color.green.bold("You have successfully installed the NativeScript CLI!"));
-        this.$logger.info("");
-        this.$logger.info("Your next step is to create a new project:");
-        this.$logger.info(color_1.color.green.bold("ns create"));
-        this.$logger.info("");
-        this.$logger.printMarkdown("If you have any questions, check Stack Overflow: `https://stackoverflow.com/questions/tagged/nativescript` and our public Discord channel: `https://nativescript.org/discord`");
+    postCommandAction(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.info("");
+            this.$logger.info(color_1.color.green.bold("You have successfully installed the NativeScript CLI!"));
+            this.$logger.info("");
+            this.$logger.info("Your next step is to create a new project:");
+            this.$logger.info(color_1.color.green.bold("ns create"));
+            this.$logger.info("");
+            this.$logger.printMarkdown("If you have any questions, check Stack Overflow: `https://stackoverflow.com/questions/tagged/nativescript` and our public Discord channel: `https://nativescript.org/discord`");
+        });
     }
 }
 exports.PostInstallCliCommand = PostInstallCliCommand;
 yok_1.injector.registerCommand("post-install-cli", PostInstallCliCommand);
+//# sourceMappingURL=post-install.js.map

package/lib/commands/prepare.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.PrepareCommand = void 0;
 const command_base_1 = require("./command-base");
@@ -17,40 +26,48 @@ class PrepareCommand extends command_base_1.ValidatePlatformCommandBase {
         this.allowedParameters = [this.$platformCommandParameter];
         this.dashedOptions = {
             watch: {
-                type: "boolean",
+                type: "boolean" /* OptionType.Boolean */,
                 default: false,
                 hasSensitiveValue: false,
             },
-            hmr: { type: "boolean", default: false, hasSensitiveValue: false },
+            hmr: { type: "boolean" /* OptionType.Boolean */, default: false, hasSensitiveValue: false },
             whatever: {
-                type: "boolean",
+                type: "boolean" /* OptionType.Boolean */,
                 default: false,
                 hasSensitiveValue: false,
             },
         };
         this.$projectData.initializeProjectData();
     }
-    async execute(args) {
-        const platform = args[0];
-        const prepareData = this.$prepareDataService.getPrepareData(this.$projectData.projectDir, platform, this.$options);
-        await this.$prepareController.prepare(prepareData);
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = args[0];
+            const prepareData = this.$prepareDataService.getPrepareData(this.$projectData.projectDir, platform, this.$options);
+            yield this.$prepareController.prepare(prepareData);
+        });
     }
-    async canExecute(args) {
-        const platform = args[0];
-        const result = (await this.$platformCommandParameter.validate(platform)) &&
-            (await this.$platformValidationService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, platform));
-        if (!this.$options.force) {
-            await this.$migrateController.validate({
-                projectDir: this.$projectData.projectDir,
-                platforms: [platform],
-            });
-        }
-        if (!result) {
-            return false;
-        }
-        const canExecuteOutput = await super.canExecuteCommandBase(platform);
-        return canExecuteOutput;
+    canExecute(args) {
+        const _super = Object.create(null, {
+            canExecuteCommandBase: { get: () => super.canExecuteCommandBase }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = args[0];
+            const result = (yield this.$platformCommandParameter.validate(platform)) &&
+                (yield this.$platformValidationService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, platform));
+            if (!this.$options.force) {
+                yield this.$migrateController.validate({
+                    projectDir: this.$projectData.projectDir,
+                    platforms: [platform],
+                });
+            }
+            if (!result) {
+                return false;
+            }
+            const canExecuteOutput = yield _super.canExecuteCommandBase.call(this, platform);
+            return canExecuteOutput;
+        });
     }
 }
 exports.PrepareCommand = PrepareCommand;
 yok_1.injector.registerCommand("prepare", PrepareCommand);
+//# sourceMappingURL=prepare.js.map

package/lib/commands/preview.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.PreviewCommand = void 0;
 const yok_1 = require("../common/yok");
@@ -22,59 +31,65 @@ class PreviewCommand {
             paths: [this.$projectData.projectDir],
         });
     }
-    async execute(args) {
-        if (!this.$options.disableNpmInstall) {
-            await this.$packageManager.install(`${PREVIEW_CLI_PACKAGE}@latest`, this.$projectData.projectDir, {
-                "save-dev": true,
-                "save-exact": true,
-            });
-        }
-        const previewCLIPath = this.getPreviewCLIPath();
-        if (!previewCLIPath) {
-            const packageManagerName = await this.$packageManager.getPackageManagerName();
-            let installCommand = "";
-            switch (packageManagerName) {
-                case constants_1.PackageManagers.yarn:
-                case constants_1.PackageManagers.yarn2:
-                    installCommand = "yarn add -D @nativescript/preview-cli";
-                    break;
-                case constants_1.PackageManagers.pnpm:
-                    installCommand = "pnpm install --save-dev @nativescript/preview-cli";
-                    break;
-                case constants_1.PackageManagers.bun:
-                    installCommand = "bun add --dev @nativescript/preview-cli";
-                case constants_1.PackageManagers.npm:
-                default:
-                    installCommand = "npm install --save-dev @nativescript/preview-cli";
-                    break;
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$options.disableNpmInstall) {
+                // ensure latest is installed
+                yield this.$packageManager.install(`${PREVIEW_CLI_PACKAGE}@latest`, this.$projectData.projectDir, {
+                    "save-dev": true,
+                    "save-exact": true,
+                });
+            }
+            const previewCLIPath = this.getPreviewCLIPath();
+            if (!previewCLIPath) {
+                const packageManagerName = yield this.$packageManager.getPackageManagerName();
+                let installCommand = "";
+                switch (packageManagerName) {
+                    case constants_1.PackageManagers.yarn:
+                    case constants_1.PackageManagers.yarn2:
+                        installCommand = "yarn add -D @nativescript/preview-cli";
+                        break;
+                    case constants_1.PackageManagers.pnpm:
+                        installCommand = "pnpm install --save-dev @nativescript/preview-cli";
+                        break;
+                    case constants_1.PackageManagers.bun:
+                        installCommand = "bun add --dev @nativescript/preview-cli";
+                    case constants_1.PackageManagers.npm:
+                    default:
+                        installCommand = "npm install --save-dev @nativescript/preview-cli";
+                        break;
+                }
+                this.$logger.info([
+                    `Uhh ohh, no Preview CLI found.`,
+                    "",
+                    `This should not happen under regular circumstances, but seems like it did somehow... :(`,
+                    `Good news though, you can install the Preview CLI by running`,
+                    "",
+                    "  " + color_1.color.green(installCommand),
+                    "",
+                    "Once installed, run this command again and everything should work!",
+                    "If it still fails, you can invoke the preview-cli directly as a last resort with",
+                    "",
+                    color_1.color.cyan("  ./node_modules/.bin/preview-cli"),
+                    "",
+                    "And if you are still having issues, try again - or reach out on Discord/open an issue on GitHub.",
+                ].join("\n"));
+                this.$errors.fail("Running preview failed.");
             }
-            this.$logger.info([
-                `Uhh ohh, no Preview CLI found.`,
-                "",
-                `This should not happen under regular circumstances, but seems like it did somehow... :(`,
-                `Good news though, you can install the Preview CLI by running`,
-                "",
-                "  " + color_1.color.green(installCommand),
-                "",
-                "Once installed, run this command again and everything should work!",
-                "If it still fails, you can invoke the preview-cli directly as a last resort with",
-                "",
-                color_1.color.cyan("  ./node_modules/.bin/preview-cli"),
-                "",
-                "And if you are still having issues, try again - or reach out on Discord/open an issue on GitHub.",
-            ].join("\n"));
-            this.$errors.fail("Running preview failed.");
-        }
-        const previewCLIBinPath = path.resolve(previewCLIPath, "./dist/index.js");
-        const commandIndex = process.argv.indexOf("preview");
-        const commandArgs = process.argv.slice(commandIndex + 1);
-        this.$childProcess.spawn(process.execPath, [previewCLIBinPath, ...commandArgs], {
-            stdio: "inherit",
+            const previewCLIBinPath = path.resolve(previewCLIPath, "./dist/index.js");
+            const commandIndex = process.argv.indexOf("preview");
+            const commandArgs = process.argv.slice(commandIndex + 1);
+            this.$childProcess.spawn(process.execPath, [previewCLIBinPath, ...commandArgs], {
+                stdio: "inherit",
+            });
         });
     }
-    async canExecute(args) {
-        return true;
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
     }
 }
 exports.PreviewCommand = PreviewCommand;
 yok_1.injector.registerCommand("preview", PreviewCommand);
+//# sourceMappingURL=preview.js.map

package/lib/commands/remove-platform.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.RemovePlatformCommand = void 0;
 const _ = require("lodash");
@@ -15,15 +24,18 @@ class RemovePlatformCommand {
     execute(args) {
         return this.$platformCommandHelper.removePlatforms(args, this.$projectData);
     }
-    async canExecute(args) {
-        if (!args || args.length === 0) {
-            this.$errors.failWithHelp("No platform specified. Please specify a platform to remove.");
-        }
-        _.each(args, (platform) => {
-            this.$platformValidationService.validatePlatform(platform, this.$projectData);
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args || args.length === 0) {
+                this.$errors.failWithHelp("No platform specified. Please specify a platform to remove.");
+            }
+            _.each(args, (platform) => {
+                this.$platformValidationService.validatePlatform(platform, this.$projectData);
+            });
+            return true;
         });
-        return true;
     }
 }
 exports.RemovePlatformCommand = RemovePlatformCommand;
 yok_1.injector.registerCommand("platform|remove", RemovePlatformCommand);
+//# sourceMappingURL=remove-platform.js.map

package/lib/commands/resources/resources-update.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.ResourcesUpdateCommand = void 0;
 const yok_1 = require("../../common/yok");
@@ -10,23 +19,29 @@ class ResourcesUpdateCommand {
         this.allowedParameters = [];
         this.$projectData.initializeProjectData();
     }
-    async execute(args) {
-        await this.$androidResourcesMigrationService.migrate(this.$projectData.getAppResourcesDirectoryPath());
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$androidResourcesMigrationService.migrate(this.$projectData.getAppResourcesDirectoryPath());
+        });
     }
-    async canExecute(args) {
-        if (!args || args.length === 0) {
-            args = ["android"];
-        }
-        for (const platform of args) {
-            if (!this.$androidResourcesMigrationService.canMigrate(platform)) {
-                this.$errors.fail(`The ${platform} does not need to have its resources updated.`);
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args || args.length === 0) {
+                // Command defaults to migrating the Android App_Resources, unless explicitly specified
+                args = ["android"];
             }
-            if (this.$androidResourcesMigrationService.hasMigrated(this.$projectData.getAppResourcesDirectoryPath())) {
-                this.$errors.fail("The App_Resources have already been updated for the Android platform.");
+            for (const platform of args) {
+                if (!this.$androidResourcesMigrationService.canMigrate(platform)) {
+                    this.$errors.fail(`The ${platform} does not need to have its resources updated.`);
+                }
+                if (this.$androidResourcesMigrationService.hasMigrated(this.$projectData.getAppResourcesDirectoryPath())) {
+                    this.$errors.fail("The App_Resources have already been updated for the Android platform.");
+                }
             }
-        }
-        return true;
+            return true;
+        });
     }
 }
 exports.ResourcesUpdateCommand = ResourcesUpdateCommand;
 yok_1.injector.registerCommand("resources|update", ResourcesUpdateCommand);
+//# sourceMappingURL=resources-update.js.map

package/lib/commands/run.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.RunVisionOSCommand = exports.RunAndroidCommand = exports.RunIosCommand = exports.RunCommandBase = void 0;
 const constants_1 = require("../common/constants");
@@ -25,35 +34,39 @@ class RunCommandBase {
         this.liveSyncCommandHelperAdditionalOptions = {};
         this.allowedParameters = [];
     }
-    async execute(args) {
-        await this.$liveSyncCommandHelper.executeCommandLiveSync(this.platform, this.liveSyncCommandHelperAdditionalOptions);
-        if (process.env.NS_IS_INTERACTIVE) {
-            this.$keyCommandHelper.attachKeyCommands(this.platform, "run");
-        }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$liveSyncCommandHelper.executeCommandLiveSync(this.platform, this.liveSyncCommandHelperAdditionalOptions);
+            if (process.env.NS_IS_INTERACTIVE) {
+                this.$keyCommandHelper.attachKeyCommands(this.platform, "run");
+            }
+        });
     }
-    async canExecute(args) {
-        if (args.length) {
-            this.$errors.failWithHelp(constants_1.ERROR_NO_VALID_SUBCOMMAND_FORMAT, "run");
-        }
-        this.platform = args[0] || this.platform;
-        if (!this.platform && !this.$hostInfo.isDarwin) {
-            this.platform = this.$devicePlatformsConstants.Android;
-        }
-        this.$projectData.initializeProjectData();
-        const platforms = this.platform
-            ? [this.platform]
-            : [
-                this.$devicePlatformsConstants.Android,
-                this.$devicePlatformsConstants.iOS,
-            ];
-        if (!this.$options.force) {
-            await this.$migrateController.validate({
-                projectDir: this.$projectData.projectDir,
-                platforms,
-            });
-        }
-        await this.$liveSyncCommandHelper.validatePlatform(this.platform);
-        return true;
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (args.length) {
+                this.$errors.failWithHelp(constants_1.ERROR_NO_VALID_SUBCOMMAND_FORMAT, "run");
+            }
+            this.platform = args[0] || this.platform;
+            if (!this.platform && !this.$hostInfo.isDarwin) {
+                this.platform = this.$devicePlatformsConstants.Android;
+            }
+            this.$projectData.initializeProjectData();
+            const platforms = this.platform
+                ? [this.platform]
+                : [
+                    this.$devicePlatformsConstants.Android,
+                    this.$devicePlatformsConstants.iOS,
+                ];
+            if (!this.$options.force) {
+                yield this.$migrateController.validate({
+                    projectDir: this.$projectData.projectDir,
+                    platforms,
+                });
+            }
+            yield this.$liveSyncCommandHelper.validatePlatform(this.platform);
+            return true;
+        });
     }
 }
 exports.RunCommandBase = RunCommandBase;
@@ -76,23 +89,27 @@ class RunIosCommand {
         this.$projectDataService = $projectDataService;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        return this.runCommand.execute(args);
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.runCommand.execute(args);
+        });
     }
-    async canExecute(args) {
-        const projectData = this.$projectDataService.getProjectData();
-        if (!this.$platformValidationService.isPlatformSupportedForOS(this.platform, projectData)) {
-            this.$errors.fail(`Applications for platform ${this.platform} can not be built on this OS`);
-        }
-        const result = (await this.runCommand.canExecute(args)) &&
-            (await this.$platformValidationService.validateOptions(this.$options.provision, this.$options.teamId, projectData, this.platform.toLowerCase()));
-        return result;
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectData = this.$projectDataService.getProjectData();
+            if (!this.$platformValidationService.isPlatformSupportedForOS(this.platform, projectData)) {
+                this.$errors.fail(`Applications for platform ${this.platform} can not be built on this OS`);
+            }
+            const result = (yield this.runCommand.canExecute(args)) &&
+                (yield this.$platformValidationService.validateOptions(this.$options.provision, this.$options.teamId, projectData, this.platform.toLowerCase()));
+            return result;
+        });
     }
 }
-exports.RunIosCommand = RunIosCommand;
 __decorate([
     (0, decorators_1.cache)()
 ], RunIosCommand.prototype, "runCommand", null);
+exports.RunIosCommand = RunIosCommand;
 yok_1.injector.registerCommand("run|ios", RunIosCommand);
 class RunAndroidCommand {
     get runCommand() {
@@ -112,30 +129,34 @@ class RunAndroidCommand {
         this.$projectData = $projectData;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        return this.runCommand.execute(args);
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.runCommand.execute(args);
+        });
     }
-    async canExecute(args) {
-        await this.runCommand.canExecute(args);
-        if (!this.$platformValidationService.isPlatformSupportedForOS(this.$devicePlatformsConstants.Android, this.$projectData)) {
-            this.$errors.fail(`Applications for platform ${this.$devicePlatformsConstants.Android} can not be built on this OS`);
-        }
-        if ((this.$options.release || this.$options.aab) &&
-            !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
-            if (this.$options.release) {
-                this.$errors.failWithHelp(constants_2.ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.runCommand.canExecute(args);
+            if (!this.$platformValidationService.isPlatformSupportedForOS(this.$devicePlatformsConstants.Android, this.$projectData)) {
+                this.$errors.fail(`Applications for platform ${this.$devicePlatformsConstants.Android} can not be built on this OS`);
             }
-            else {
-                this.$errors.failWithHelp(constants_2.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
+            if ((this.$options.release || this.$options.aab) &&
+                !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
+                if (this.$options.release) {
+                    this.$errors.failWithHelp(constants_2.ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
+                }
+                else {
+                    this.$errors.failWithHelp(constants_2.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
+                }
             }
-        }
-        return this.$platformValidationService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, this.$devicePlatformsConstants.Android.toLowerCase());
+            return this.$platformValidationService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, this.$devicePlatformsConstants.Android.toLowerCase());
+        });
     }
 }
-exports.RunAndroidCommand = RunAndroidCommand;
 __decorate([
     (0, decorators_1.cache)()
 ], RunAndroidCommand.prototype, "runCommand", null);
+exports.RunAndroidCommand = RunAndroidCommand;
 yok_1.injector.registerCommand("run|android", RunAndroidCommand);
 class RunVisionOSCommand extends RunIosCommand {
     get platform() {
@@ -154,3 +175,4 @@ class RunVisionOSCommand extends RunIosCommand {
 exports.RunVisionOSCommand = RunVisionOSCommand;
 yok_1.injector.registerCommand("run|vision", RunVisionOSCommand);
 yok_1.injector.registerCommand("run|visionos", RunVisionOSCommand);
+//# sourceMappingURL=run.js.map