@akylas/nativescript-cli 8.7.2

package/lib/commands/deploy.js

@@ -0,0 +1,78 @@
+"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");
+const command_base_1 = require("./command-base");
+const helpers_1 = require("../common/helpers");
+const yok_1 = require("../common/yok");
+class DeployOnDeviceCommand extends command_base_1.ValidatePlatformCommandBase {
+    constructor($platformValidationService, $platformCommandParameter, $options, $projectData, $errors, $mobileHelper, $platformsDataService, $deployCommandHelper, $migrateController) {
+        super($options, $platformsDataService, $platformValidationService, $projectData);
+        this.$platformCommandParameter = $platformCommandParameter;
+        this.$errors = $errors;
+        this.$mobileHelper = $mobileHelper;
+        this.$deployCommandHelper = $deployCommandHelper;
+        this.$migrateController = $migrateController;
+        this.allowedParameters = [];
+        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];
+            yield 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;
+            }
+            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);
+                }
+            }
+            const result = yield _super.canExecuteCommandBase.call(this, platform, {
+                validateOptions: true,
+            });
+            return result;
+        });
+    }
+}
+exports.DeployOnDeviceCommand = DeployOnDeviceCommand;
+yok_1.injector.registerCommand("deploy", DeployOnDeviceCommand);

package/lib/commands/extensibility/install-extension.js

@@ -0,0 +1,33 @@
+"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");
+class InstallExtensionCommand {
+    constructor($extensibilityService, $stringParameterBuilder, $logger) {
+        this.$extensibilityService = $extensibilityService;
+        this.$stringParameterBuilder = $stringParameterBuilder;
+        this.$logger = $logger;
+        this.allowedParameters = [
+            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}.`);
+        });
+    }
+}
+exports.InstallExtensionCommand = InstallExtensionCommand;
+yok_1.injector.registerCommand("extension|install", InstallExtensionCommand);

package/lib/commands/extensibility/list-extensions.js

@@ -0,0 +1,40 @@
+"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");
+const helpers = require("../../common/helpers");
+const yok_1 = require("../../common/yok");
+class ListExtensionsCommand {
+    constructor($extensibilityService, $logger) {
+        this.$extensibilityService = $extensibilityService;
+        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.");
+            }
+        });
+    }
+}
+exports.ListExtensionsCommand = ListExtensionsCommand;
+yok_1.injector.registerCommand("extension|*list", ListExtensionsCommand);

package/lib/commands/extensibility/uninstall-extension.js

@@ -0,0 +1,32 @@
+"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");
+class UninstallExtensionCommand {
+    constructor($extensibilityService, $stringParameterBuilder, $logger) {
+        this.$extensibilityService = $extensibilityService;
+        this.$stringParameterBuilder = $stringParameterBuilder;
+        this.$logger = $logger;
+        this.allowedParameters = [
+            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}`);
+        });
+    }
+}
+exports.UninstallExtensionCommand = UninstallExtensionCommand;
+yok_1.injector.registerCommand("extension|uninstall", UninstallExtensionCommand);

package/lib/commands/fonts.js

@@ -0,0 +1,64 @@
+"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");
+const constants = require("../constants");
+const fontFinder = require("font-finder");
+const helpers_1 = require("../common/helpers");
+const path = require("path");
+class FontsCommand {
+    constructor($projectData, $fs, $logger, $projectConfigService) {
+        this.$projectData = $projectData;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$projectConfigService = $projectConfigService;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    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());
+        });
+    }
+}
+exports.FontsCommand = FontsCommand;
+yok_1.injector.registerCommand("fonts", FontsCommand);

package/lib/commands/generate-assets.js

@@ -0,0 +1,71 @@
+"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.GenerateSplashScreensCommand = exports.GenerateIconsCommand = exports.GenerateCommandBase = void 0;
+const yok_1 = require("../common/yok");
+class GenerateCommandBase {
+    constructor($options, $injector, $projectData, $stringParameterBuilder, $assetsGenerationService) {
+        this.$options = $options;
+        this.$injector = $injector;
+        this.$projectData = $projectData;
+        this.$stringParameterBuilder = $stringParameterBuilder;
+        this.$assetsGenerationService = $assetsGenerationService;
+        this.allowedParameters = [
+            this.$stringParameterBuilder.createMandatoryParameter("You have to provide path to image to generate other images based on it."),
+        ];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [imagePath] = args;
+            yield this.generate(imagePath, this.$options.background);
+        });
+    }
+}
+exports.GenerateCommandBase = GenerateCommandBase;
+class GenerateIconsCommand extends GenerateCommandBase {
+    constructor($options, $injector, $projectData, $stringParameterBuilder, $assetsGenerationService) {
+        super($options, $injector, $projectData, $stringParameterBuilder, $assetsGenerationService);
+        this.$options = $options;
+        this.$projectData = $projectData;
+        this.$stringParameterBuilder = $stringParameterBuilder;
+    }
+    generate(imagePath, background) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$assetsGenerationService.generateIcons({
+                imagePath,
+                background,
+                projectDir: this.$projectData.projectDir,
+            });
+        });
+    }
+}
+exports.GenerateIconsCommand = GenerateIconsCommand;
+yok_1.injector.registerCommand("resources|generate|icons", GenerateIconsCommand);
+class GenerateSplashScreensCommand extends GenerateCommandBase {
+    constructor($options, $injector, $projectData, $stringParameterBuilder, $assetsGenerationService) {
+        super($options, $injector, $projectData, $stringParameterBuilder, $assetsGenerationService);
+        this.$options = $options;
+        this.$projectData = $projectData;
+        this.$stringParameterBuilder = $stringParameterBuilder;
+    }
+    generate(imagePath, background) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$assetsGenerationService.generateSplashScreens({
+                imagePath,
+                background,
+                projectDir: this.$projectData.projectDir,
+            });
+        });
+    }
+}
+exports.GenerateSplashScreensCommand = GenerateSplashScreensCommand;
+yok_1.injector.registerCommand("resources|generate|splashes", GenerateSplashScreensCommand);

package/lib/commands/generate-help.js

@@ -0,0 +1,26 @@
+"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.GenerateHelpCommand = void 0;
+const yok_1 = require("../common/yok");
+class GenerateHelpCommand {
+    constructor($helpService) {
+        this.$helpService = $helpService;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$helpService.generateHtmlPages();
+        });
+    }
+}
+exports.GenerateHelpCommand = GenerateHelpCommand;
+yok_1.injector.registerCommand("dev-generate-help", GenerateHelpCommand);

package/lib/commands/generate.js

@@ -0,0 +1,78 @@
+"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.GenerateCommand = void 0;
+const schematics_executor_1 = require("@nativescript/schematics-executor");
+const yok_1 = require("../common/yok");
+class GenerateCommand {
+    constructor($logger, $options, $errors) {
+        this.$logger = $logger;
+        this.$options = $options;
+        this.$errors = $errors;
+        this.allowedParameters = [];
+    }
+    execute(_rawArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield (0, schematics_executor_1.run)(this.executionOptions);
+            }
+            catch (error) {
+                this.$errors.fail(error.message);
+            }
+        });
+    }
+    canExecute(rawArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setExecutionOptions(rawArgs);
+            this.validateExecutionOptions();
+            return true;
+        });
+    }
+    validateExecutionOptions() {
+        if (!this.executionOptions.schematic) {
+            this.$errors.failWithHelp(`The generate command requires a schematic name to be specified.`);
+        }
+    }
+    setExecutionOptions(rawArgs) {
+        const options = this.parseRawArgs(rawArgs);
+        this.executionOptions = Object.assign(Object.assign({}, options), { logger: this.$logger, directory: process.cwd() });
+    }
+    parseRawArgs(rawArgs) {
+        const collection = this.$options.collection;
+        const schematic = rawArgs.shift();
+        const { options, args } = parseSchematicSettings(rawArgs);
+        return {
+            collection,
+            schematic,
+            schematicOptions: options,
+            schematicArgs: args,
+        };
+    }
+}
+exports.GenerateCommand = GenerateCommand;
+function parseSchematicSettings(rawArgs) {
+    const [optionStrings, args] = partition(rawArgs, (item) => item.includes("="));
+    const options = optionStrings
+        .map((o) => o.split("="))
+        .map(([key, ...value]) => [key, value.join("=")])
+        .reduce((obj, [key, value]) => {
+        return Object.assign(Object.assign({}, obj), { [key]: value });
+    }, {});
+    return { options, args };
+}
+function partition(array, predicate) {
+    return array.reduce(([pass, fail], item) => {
+        return predicate(item)
+            ? [[...pass, item], fail]
+            : [pass, [...fail, item]];
+    }, [[], []]);
+}
+yok_1.injector.registerCommand("generate", GenerateCommand);

package/lib/commands/info.js

@@ -0,0 +1,26 @@
+"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.InfoCommand = void 0;
+const yok_1 = require("../common/yok");
+class InfoCommand {
+    constructor($infoService) {
+        this.$infoService = $infoService;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$infoService.printComponentsInfo();
+        });
+    }
+}
+exports.InfoCommand = InfoCommand;
+yok_1.injector.registerCommand("info", InfoCommand);

package/lib/commands/install.js

@@ -0,0 +1,80 @@
+"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.InstallCommand = void 0;
+const os_1 = require("os");
+const yok_1 = require("../common/yok");
+class InstallCommand {
+    constructor($options, $mobileHelper, $platformsDataService, $platformCommandHelper, $projectData, $projectDataService, $pluginsService, $logger, $fs, $stringParameter, $packageManager) {
+        this.$options = $options;
+        this.$mobileHelper = $mobileHelper;
+        this.$platformsDataService = $platformsDataService;
+        this.$platformCommandHelper = $platformCommandHelper;
+        this.$projectData = $projectData;
+        this.$projectDataService = $projectDataService;
+        this.$pluginsService = $pluginsService;
+        this.$logger = $logger;
+        this.$fs = $fs;
+        this.$stringParameter = $stringParameter;
+        this.$packageManager = $packageManager;
+        this.enableHooks = false;
+        this.allowedParameters = [this.$stringParameter];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return args[0]
+                ? this.installModule(args[0])
+                : this.installProjectDependencies();
+        });
+    }
+    installProjectDependencies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let error = "";
+            yield this.$pluginsService.ensureAllDependenciesAreInstalled(this.$projectData);
+            for (const platform of this.$mobileHelper.platformNames) {
+                const platformData = this.$platformsDataService.getPlatformData(platform, this.$projectData);
+                const frameworkPackageData = this.$projectDataService.getRuntimePackage(this.$projectData.projectDir, platformData.platformNameLowerCase);
+                if (frameworkPackageData && frameworkPackageData.version) {
+                    try {
+                        const platformProjectService = platformData.platformProjectService;
+                        yield platformProjectService.validate(this.$projectData, this.$options);
+                        yield this.$platformCommandHelper.addPlatforms([`${platform}@${frameworkPackageData.version}`], this.$projectData, this.$options.frameworkPath);
+                    }
+                    catch (err) {
+                        error = `${error}${os_1.EOL}${err}`;
+                    }
+                }
+            }
+            if (error) {
+                this.$logger.error(error);
+            }
+        });
+    }
+    installModule(moduleName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectDir = this.$projectData.projectDir;
+            const devPrefix = "nativescript-dev-";
+            if (!this.$fs.exists(moduleName) && moduleName.indexOf(devPrefix) !== 0) {
+                moduleName = devPrefix + moduleName;
+            }
+            yield this.$packageManager.install(moduleName, projectDir, {
+                "save-dev": true,
+                disableNpmInstall: this.$options.disableNpmInstall,
+                frameworkPath: this.$options.frameworkPath,
+                ignoreScripts: this.$options.ignoreScripts,
+                path: this.$options.path,
+            });
+        });
+    }
+}
+exports.InstallCommand = InstallCommand;
+yok_1.injector.registerCommand("install", InstallCommand);

package/lib/commands/list-platforms.js

@@ -0,0 +1,45 @@
+"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.ListPlatformsCommand = void 0;
+const helpers = require("../common/helpers");
+const yok_1 = require("../common/yok");
+class ListPlatformsCommand {
+    constructor($platformCommandHelper, $projectData, $logger) {
+        this.$platformCommandHelper = $platformCommandHelper;
+        this.$projectData = $projectData;
+        this.$logger = $logger;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const installedPlatforms = this.$platformCommandHelper.getInstalledPlatforms(this.$projectData);
+            if (installedPlatforms.length > 0) {
+                const preparedPlatforms = this.$platformCommandHelper.getPreparedPlatforms(this.$projectData);
+                if (preparedPlatforms.length > 0) {
+                    this.$logger.info("The project is prepared for: ", helpers.formatListOfNames(preparedPlatforms, "and"));
+                }
+                else {
+                    this.$logger.info("The project is not prepared for any platform");
+                }
+                this.$logger.info("Installed platforms: ", helpers.formatListOfNames(installedPlatforms, "and"));
+            }
+            else {
+                const formattedPlatformsList = helpers.formatListOfNames(this.$platformCommandHelper.getAvailablePlatforms(this.$projectData), "and");
+                this.$logger.info("Available platforms for this OS: ", formattedPlatformsList);
+                this.$logger.info("No installed platforms found. Use $ ns platform add");
+            }
+        });
+    }
+}
+exports.ListPlatformsCommand = ListPlatformsCommand;
+yok_1.injector.registerCommand("platform|*list", ListPlatformsCommand);

package/lib/commands/migrate.js

@@ -0,0 +1,44 @@
+"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.MigrateCommand = void 0;
+const yok_1 = require("../common/yok");
+class MigrateCommand {
+    constructor($devicePlatformsConstants, $migrateController, $staticConfig, $projectData, $logger) {
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$migrateController = $migrateController;
+        this.$staticConfig = $staticConfig;
+        this.$projectData = $projectData;
+        this.$logger = $logger;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const migrationData = {
+                projectDir: this.$projectData.projectDir,
+                platforms: [
+                    this.$devicePlatformsConstants.Android,
+                    this.$devicePlatformsConstants.iOS,
+                ],
+            };
+            const shouldMigrateResult = yield this.$migrateController.shouldMigrate(migrationData);
+            if (!shouldMigrateResult) {
+                const cliVersion = this.$staticConfig.version;
+                this.$logger.printMarkdown(`__Project is compatible with NativeScript \`v${cliVersion}\`__`);
+                return;
+            }
+            yield this.$migrateController.migrate(migrationData);
+        });
+    }
+}
+exports.MigrateCommand = MigrateCommand;
+yok_1.injector.registerCommand("migrate", MigrateCommand);