@akylas/nativescript-cli 8.7.2

package/lib/commands/platform-clean.js

@@ -0,0 +1,54 @@
+"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.CleanCommand = void 0;
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+class CleanCommand {
+    constructor($errors, $options, $platformCommandHelper, $platformValidationService, $platformEnvironmentRequirements, $projectData) {
+        this.$errors = $errors;
+        this.$options = $options;
+        this.$platformCommandHelper = $platformCommandHelper;
+        this.$platformValidationService = $platformValidationService;
+        this.$platformEnvironmentRequirements = $platformEnvironmentRequirements;
+        this.$projectData = $projectData;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$platformCommandHelper.cleanPlatforms(args, this.$projectData, this.$options.frameworkPath);
+        });
+    }
+    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 clean.");
+            }
+            _.each(args, (platform) => {
+                this.$platformValidationService.validatePlatform(platform, this.$projectData);
+            });
+            for (const platform of args) {
+                this.$platformValidationService.validatePlatformInstalled(platform, this.$projectData);
+                const currentRuntimeVersion = this.$platformCommandHelper.getCurrentPlatformVersion(platform, this.$projectData);
+                yield this.$platformEnvironmentRequirements.checkEnvironmentRequirements({
+                    platform,
+                    projectDir: this.$projectData.projectDir,
+                    runtimeVersion: currentRuntimeVersion,
+                    options: this.$options,
+                });
+            }
+            return true;
+        });
+    }
+}
+exports.CleanCommand = CleanCommand;
+yok_1.injector.registerCommand("platform|clean", CleanCommand);

package/lib/commands/plugin/add-plugin.js

@@ -0,0 +1,43 @@
+"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.AddPluginCommand = void 0;
+const _ = require("lodash");
+const yok_1 = require("../../common/yok");
+class AddPluginCommand {
+    constructor($pluginsService, $projectData, $errors) {
+        this.$pluginsService = $pluginsService;
+        this.$projectData = $projectData;
+        this.$errors = $errors;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$pluginsService.add(args[0], this.$projectData);
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args[0]) {
+                this.$errors.failWithHelp("You must specify plugin name.");
+            }
+            const installedPlugins = yield this.$pluginsService.getAllInstalledPlugins(this.$projectData);
+            const pluginName = args[0].toLowerCase();
+            if (_.some(installedPlugins, (plugin) => plugin.name.toLowerCase() === pluginName)) {
+                this.$errors.fail(`Plugin "${pluginName}" is already installed.`);
+            }
+            return true;
+        });
+    }
+}
+exports.AddPluginCommand = AddPluginCommand;
+yok_1.injector.registerCommand(["plugin|add", "plugin|install"], AddPluginCommand);

package/lib/commands/plugin/build-plugin.js

@@ -0,0 +1,70 @@
+"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.BuildPluginCommand = void 0;
+const os_1 = require("os");
+const path = require("path");
+const constants = require("../../constants");
+const yok_1 = require("../../common/yok");
+class BuildPluginCommand {
+    constructor($androidPluginBuildService, $errors, $logger, $fs, $options, $tempService, $projectData) {
+        this.$androidPluginBuildService = $androidPluginBuildService;
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$fs = $fs;
+        this.$options = $options;
+        this.$tempService = $tempService;
+        this.$projectData = $projectData;
+        this.allowedParameters = [];
+        this.pluginProjectPath = path.resolve(this.$options.path || ".");
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platformsAndroidPath = path.join(this.pluginProjectPath, constants.PLATFORMS_DIR_NAME, "android");
+            let pluginName = "";
+            const pluginPackageJsonPath = path.join(this.pluginProjectPath, constants.PACKAGE_JSON_FILE_NAME);
+            if (this.$fs.exists(pluginPackageJsonPath)) {
+                const packageJsonContents = this.$fs.readJson(pluginPackageJsonPath);
+                if (packageJsonContents && packageJsonContents["name"]) {
+                    pluginName = packageJsonContents["name"];
+                }
+            }
+            const tempAndroidProject = yield this.$tempService.mkdirSync("android-project");
+            const gradleArgs = (this.$projectData.nsConfig.android.gradleArgs || [].concat(this.$options.gradleArgs || []));
+            const options = {
+                gradlePath: this.$options.gradlePath,
+                gradleArgs,
+                aarOutputDir: platformsAndroidPath,
+                platformsAndroidDirPath: platformsAndroidPath,
+                pluginName: pluginName,
+                tempPluginDirPath: tempAndroidProject,
+            };
+            const androidPluginBuildResult = yield this.$androidPluginBuildService.buildAar(options);
+            if (androidPluginBuildResult) {
+                this.$logger.info(`${pluginName} successfully built aar at ${platformsAndroidPath}.${os_1.EOL}Temporary Android project can be found at ${tempAndroidProject}.`);
+            }
+            const migratedIncludeGradle = this.$androidPluginBuildService.migrateIncludeGradle(options);
+            if (migratedIncludeGradle) {
+                this.$logger.info(`${pluginName} include gradle updated.`);
+            }
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$fs.exists(path.join(this.pluginProjectPath, constants.PLATFORMS_DIR_NAME, "android"))) {
+                this.$errors.fail("No plugin found at the current directory, or the plugin does not need to have its platforms/android components built into an `.aar`.");
+            }
+            return true;
+        });
+    }
+}
+exports.BuildPluginCommand = BuildPluginCommand;
+yok_1.injector.registerCommand("plugin|build", BuildPluginCommand);

package/lib/commands/plugin/create-plugin.js

@@ -0,0 +1,175 @@
+"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.CreatePluginCommand = void 0;
+const path = require("path");
+const helpers_1 = require("../../common/helpers");
+const yok_1 = require("../../common/yok");
+class CreatePluginCommand {
+    constructor($options, $errors, $terminalSpinnerService, $logger, $pacoteService, $fs, $childProcess, $prompter, $packageManager) {
+        this.$options = $options;
+        this.$errors = $errors;
+        this.$terminalSpinnerService = $terminalSpinnerService;
+        this.$logger = $logger;
+        this.$pacoteService = $pacoteService;
+        this.$fs = $fs;
+        this.$childProcess = $childProcess;
+        this.$prompter = $prompter;
+        this.$packageManager = $packageManager;
+        this.allowedParameters = [];
+        this.userMessage = "What is your GitHub username?\n(will be used to update the Github URLs in the plugin's package.json)";
+        this.nameMessage = "What will be the name of your plugin?\n(use lowercase characters and dashes only)";
+        this.includeTypeScriptDemoMessage = 'Do you want to include a "TypeScript NativeScript" application linked with your plugin to make development easier?';
+        this.includeAngularDemoMessage = 'Do you want to include an "Angular NativeScript" application linked with your plugin to make development easier?';
+        this.pathAlreadyExistsMessageTemplate = "Path already exists and is not empty %s";
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pluginRepoName = args[0];
+            const pathToProject = this.$options.path;
+            const selectedTemplate = this.$options.template;
+            const selectedPath = path.resolve(pathToProject || ".");
+            const projectDir = path.join(selectedPath, pluginRepoName);
+            this.ensurePackageDir(projectDir);
+            try {
+                yield this.downloadPackage(selectedTemplate, projectDir);
+                yield this.setupSeed(projectDir, pluginRepoName);
+            }
+            catch (err) {
+                this.$fs.deleteDirectory(projectDir);
+                throw err;
+            }
+            this.$logger.printMarkdown("Solution for `%s` was successfully created.", pluginRepoName);
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args[0]) {
+                this.$errors.failWithHelp("You must specify the plugin repository name.");
+            }
+            return true;
+        });
+    }
+    setupSeed(projectDir, pluginRepoName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.printMarkdown("Executing initial plugin configuration script...");
+            const config = this.$options;
+            const spinner = this.$terminalSpinnerService.createSpinner();
+            const cwd = path.join(projectDir, "src");
+            try {
+                spinner.start();
+                const npmOptions = { silent: true };
+                yield this.$packageManager.install(cwd, cwd, npmOptions);
+            }
+            finally {
+                spinner.stop();
+            }
+            const gitHubUsername = yield this.getGitHubUsername(config.username);
+            const pluginNameSource = yield this.getPluginNameSource(config.pluginName, pluginRepoName);
+            const includeTypescriptDemo = yield this.getShouldIncludeDemoResult(config.includeTypeScriptDemo, this.includeTypeScriptDemoMessage);
+            const includeAngularDemo = yield this.getShouldIncludeDemoResult(config.includeAngularDemo, this.includeAngularDemoMessage);
+            if (!(0, helpers_1.isInteractive)() &&
+                (!config.username ||
+                    !config.pluginName ||
+                    !config.includeAngularDemo ||
+                    !config.includeTypeScriptDemo)) {
+                this.$logger.printMarkdown("Using default values for plugin creation options since your shell is not interactive.");
+            }
+            const pathToPostCloneScript = path.join("scripts", "postclone");
+            const params = [
+                pathToPostCloneScript,
+                `gitHubUsername=${gitHubUsername}`,
+                `pluginName=${pluginNameSource}`,
+                "initGit=y",
+                `includeTypeScriptDemo=${includeTypescriptDemo}`,
+                `includeAngularDemo=${includeAngularDemo}`,
+            ];
+            const outputScript = yield this.$childProcess.spawnFromEvent(process.execPath, params, "close", { stdio: "inherit", cwd, timeout: 10000 });
+            if (outputScript && outputScript.stdout) {
+                this.$logger.printMarkdown(outputScript.stdout);
+            }
+        });
+    }
+    ensurePackageDir(projectDir) {
+        this.$fs.createDirectory(projectDir);
+        if (this.$fs.exists(projectDir) && !this.$fs.isEmptyDir(projectDir)) {
+            this.$errors.fail(this.pathAlreadyExistsMessageTemplate, projectDir);
+        }
+    }
+    downloadPackage(selectedTemplate, projectDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (selectedTemplate) {
+                this.$logger.printMarkdown("Make sure your custom template is compatible with the Plugin Seed at https://github.com/NativeScript/nativescript-plugin-seed/");
+            }
+            else {
+                this.$logger.printMarkdown("Downloading the latest version of NativeScript Plugin Seed...");
+            }
+            const spinner = this.$terminalSpinnerService.createSpinner();
+            const packageToInstall = selectedTemplate ||
+                "https://github.com/NativeScript/nativescript-plugin-seed/archive/master.tar.gz";
+            try {
+                spinner.start();
+                yield this.$pacoteService.extractPackage(packageToInstall, projectDir);
+            }
+            finally {
+                spinner.stop();
+            }
+        });
+    }
+    getGitHubUsername(gitHubUsername) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!gitHubUsername) {
+                gitHubUsername = "NativeScriptDeveloper";
+                if ((0, helpers_1.isInteractive)()) {
+                    gitHubUsername = yield this.$prompter.getString(this.userMessage, {
+                        allowEmpty: false,
+                        defaultAction: () => {
+                            return gitHubUsername;
+                        },
+                    });
+                }
+            }
+            return gitHubUsername;
+        });
+    }
+    getPluginNameSource(pluginNameSource, pluginRepoName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!pluginNameSource) {
+                const prefix = "nativescript-";
+                pluginNameSource = pluginRepoName.toLowerCase().startsWith(prefix)
+                    ? pluginRepoName.slice(prefix.length, pluginRepoName.length)
+                    : pluginRepoName;
+                if ((0, helpers_1.isInteractive)()) {
+                    pluginNameSource = yield this.$prompter.getString(this.nameMessage, {
+                        allowEmpty: false,
+                        defaultAction: () => {
+                            return pluginNameSource;
+                        },
+                    });
+                }
+            }
+            return pluginNameSource;
+        });
+    }
+    getShouldIncludeDemoResult(includeDemoOption, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let shouldIncludeDemo = !!includeDemoOption;
+            if (!includeDemoOption && (0, helpers_1.isInteractive)()) {
+                shouldIncludeDemo = yield this.$prompter.confirm(message, () => {
+                    return true;
+                });
+            }
+            return shouldIncludeDemo ? "y" : "n";
+        });
+    }
+}
+exports.CreatePluginCommand = CreatePluginCommand;
+yok_1.injector.registerCommand(["plugin|create"], CreatePluginCommand);

package/lib/commands/plugin/list-plugins.js

@@ -0,0 +1,54 @@
+"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.ListPluginsCommand = void 0;
+const helpers_1 = require("../../common/helpers");
+const yok_1 = require("../../common/yok");
+const color_1 = require("../../color");
+class ListPluginsCommand {
+    constructor($pluginsService, $projectData, $logger) {
+        this.$pluginsService = $pluginsService;
+        this.$projectData = $projectData;
+        this.$logger = $logger;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const installedPlugins = this.$pluginsService.getDependenciesFromPackageJson(this.$projectData.projectDir);
+            const headers = ["Plugin", "Version"];
+            const dependenciesData = this.createTableCells(installedPlugins.dependencies);
+            const dependenciesTable = (0, helpers_1.createTable)(headers, dependenciesData);
+            this.$logger.info("Dependencies:");
+            this.$logger.info(dependenciesTable.toString());
+            if (installedPlugins.devDependencies &&
+                installedPlugins.devDependencies.length) {
+                const devDependenciesData = this.createTableCells(installedPlugins.devDependencies);
+                const devDependenciesTable = (0, helpers_1.createTable)(headers, devDependenciesData);
+                this.$logger.info("Dev Dependencies:");
+                this.$logger.info(devDependenciesTable.toString());
+            }
+            else {
+                this.$logger.info("There are no dev dependencies.");
+            }
+            const viewDependenciesCommand = color_1.color.cyan("npm view <pluginName> grep dependencies");
+            const viewDevDependenciesCommand = color_1.color.cyan("npm view <pluginName> grep devDependencies");
+            this.$logger.warn("NOTE:");
+            this.$logger.warn(`If you want to check the dependencies of installed plugin use ${viewDependenciesCommand}`);
+            this.$logger.warn(`If you want to check the dev dependencies of installed plugin use ${viewDevDependenciesCommand}`);
+        });
+    }
+    createTableCells(items) {
+        return items.map((item) => [item.name, item.version]);
+    }
+}
+exports.ListPluginsCommand = ListPluginsCommand;
+yok_1.injector.registerCommand("plugin|*list", ListPluginsCommand);

package/lib/commands/plugin/remove-plugin.js

@@ -0,0 +1,52 @@
+"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.RemovePluginCommand = void 0;
+const _ = require("lodash");
+const yok_1 = require("../../common/yok");
+class RemovePluginCommand {
+    constructor($pluginsService, $errors, $logger, $projectData) {
+        this.$pluginsService = $pluginsService;
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$projectData = $projectData;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$pluginsService.remove(args[0], this.$projectData);
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args[0]) {
+                this.$errors.failWithHelp("You must specify plugin name.");
+            }
+            let pluginNames = [];
+            try {
+                const installedPlugins = yield this.$pluginsService.getAllInstalledPlugins(this.$projectData);
+                pluginNames = installedPlugins.map((pl) => pl.name);
+            }
+            catch (err) {
+                this.$logger.trace("Error while installing plugins. Error is:", err);
+                pluginNames = _.keys(this.$projectData.dependencies);
+            }
+            const pluginName = args[0].toLowerCase();
+            if (!_.some(pluginNames, (name) => name.toLowerCase() === pluginName)) {
+                this.$errors.fail(`Plugin "${pluginName}" is not installed.`);
+            }
+            return true;
+        });
+    }
+}
+exports.RemovePluginCommand = RemovePluginCommand;
+yok_1.injector.registerCommand("plugin|remove", RemovePluginCommand);

package/lib/commands/plugin/update-plugin.js

@@ -0,0 +1,52 @@
+"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");
+const yok_1 = require("../../common/yok");
+class UpdatePluginCommand {
+    constructor($pluginsService, $projectData, $errors) {
+        this.$pluginsService = $pluginsService;
+        this.$projectData = $projectData;
+        this.$errors = $errors;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    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);
+            }
+        });
+    }
+    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;
+        });
+    }
+}
+exports.UpdatePluginCommand = UpdatePluginCommand;
+yok_1.injector.registerCommand("plugin|update", UpdatePluginCommand);

package/lib/commands/post-install.js

@@ -0,0 +1,57 @@
+"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");
+const yok_1 = require("../common/yok");
+const color_1 = require("../color");
+class PostInstallCliCommand {
+    constructor($fs, $commandsService, $helpService, $settingsService, $analyticsService, $logger, $hostInfo) {
+        this.$fs = $fs;
+        this.$commandsService = $commandsService;
+        this.$helpService = $helpService;
+        this.$settingsService = $settingsService;
+        this.$analyticsService = $analyticsService;
+        this.$logger = $logger;
+        this.$hostInfo = $hostInfo;
+        this.disableAnalytics = true;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isRunningWithSudoUser = !!process.env.SUDO_USER;
+            if (!this.$hostInfo.isWindows) {
+                if (isRunningWithSudoUser) {
+                    yield this.$fs.setCurrentUserAsOwner(this.$settingsService.getProfileDir(), process.env.SUDO_USER);
+                }
+            }
+            const canExecutePostInstallTask = !isRunningWithSudoUser || (0, helpers_1.doesCurrentNpmCommandMatch)([/^--unsafe-perm$/]);
+            if (canExecutePostInstallTask) {
+                yield this.$helpService.generateHtmlPages();
+                yield this.$analyticsService.checkConsent();
+                yield this.$commandsService.tryExecuteCommand("autocomplete", []);
+            }
+        });
+    }
+    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);

package/lib/commands/prepare.js

@@ -0,0 +1,63 @@
+"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");
+const yok_1 = require("../common/yok");
+class PrepareCommand extends command_base_1.ValidatePlatformCommandBase {
+    constructor($options, $prepareController, $platformValidationService, $projectData, $platformCommandParameter, $platformsDataService, $prepareDataService, $migrateController) {
+        super($options, $platformsDataService, $platformValidationService, $projectData);
+        this.$prepareController = $prepareController;
+        this.$platformCommandParameter = $platformCommandParameter;
+        this.$prepareDataService = $prepareDataService;
+        this.$migrateController = $migrateController;
+        this.allowedParameters = [this.$platformCommandParameter];
+        this.dashedOptions = {
+            watch: {
+                type: "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];
+            const prepareData = this.$prepareDataService.getPrepareData(this.$projectData.projectDir, platform, this.$options);
+            yield this.$prepareController.prepare(prepareData);
+        });
+    }
+    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);