@akylas/nativescript-cli 8.7.2

package/lib/services/device/device-install-app-service.js

@@ -0,0 +1,118 @@
+"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.DeviceInstallAppService = void 0;
+const constants_1 = require("../../constants");
+const path = require("path");
+const yok_1 = require("../../common/yok");
+class DeviceInstallAppService {
+    constructor($analyticsService, $buildArtifactsService, $buildInfoFileService, $fs, $logger, $mobileHelper, $projectDataService, $platformsDataService) {
+        this.$analyticsService = $analyticsService;
+        this.$buildArtifactsService = $buildArtifactsService;
+        this.$buildInfoFileService = $buildInfoFileService;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$mobileHelper = $mobileHelper;
+        this.$projectDataService = $projectDataService;
+        this.$platformsDataService = $platformsDataService;
+    }
+    installOnDevice(device, buildData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.info(`Installing on device ${device.deviceInfo.identifier}...`);
+            const platform = device.deviceInfo.platform.toLowerCase();
+            const projectData = this.$projectDataService.getProjectData(buildData.projectDir);
+            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Deploy",
+                device,
+                projectDir: projectData.projectDir,
+            });
+            const buildOutputOptions = platformData.getValidBuildOutputData(buildData);
+            const outputPath = buildData.outputPath || platformData.getBuildOutputPath(buildData);
+            const packages = yield this.$buildArtifactsService.getAllAppPackages(outputPath, buildOutputOptions);
+            let packageFile;
+            if (packages.length === 1) {
+                packageFile = packages.at(0).packageName;
+            }
+            else if (device.deviceInfo.abis) {
+                packages.find(({ packageName }) => {
+                    if (device.deviceInfo.abis.some((abi) => packageName.includes(abi))) {
+                        packageFile = packageName;
+                        return true;
+                    }
+                });
+            }
+            else {
+                const universalPackage = packages.find((p) => p.packageName.includes("universal"));
+                if (universalPackage) {
+                    packageFile = universalPackage.packageName;
+                }
+            }
+            if (!packageFile) {
+                this.$logger.error(`Could not find a package corresponding to the device with identifier '${device.deviceInfo.identifier}'.`);
+                return;
+            }
+            yield platformData.platformProjectService.cleanDeviceTempFolder(device.deviceInfo.identifier, projectData);
+            const appIdentifier = projectData.projectIdentifiers[platform];
+            const outputFilePath = buildData.outputPath || platformData.getBuildOutputPath(buildData);
+            yield device.applicationManager.reinstallApplication(appIdentifier, packageFile, buildData);
+            yield this.updateHashesOnDevice({
+                device,
+                appIdentifier,
+                outputFilePath,
+                platformData,
+            });
+            if (!buildData.release) {
+                yield this.$buildInfoFileService.saveDeviceBuildInfo(device, projectData, outputFilePath);
+            }
+            this.$logger.info(`Successfully installed on device with identifier '${device.deviceInfo.identifier} using package ${packageFile}'.`);
+        });
+    }
+    installOnDeviceIfNeeded(device, buildData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const shouldInstall = yield this.shouldInstall(device, buildData);
+            if (shouldInstall) {
+                yield this.installOnDevice(device, buildData);
+            }
+        });
+    }
+    shouldInstall(device, buildData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectData = this.$projectDataService.getProjectData(buildData.projectDir);
+            const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
+            const platform = device.deviceInfo.platform;
+            if (!(yield device.applicationManager.isApplicationInstalled(projectData.projectIdentifiers[platform.toLowerCase()]))) {
+                return true;
+            }
+            const deviceBuildInfo = yield this.$buildInfoFileService.getDeviceBuildInfo(device, projectData);
+            const localBuildInfo = this.$buildInfoFileService.getLocalBuildInfo(platformData, Object.assign(Object.assign({}, buildData), { buildForDevice: !device.isEmulator }));
+            return (!localBuildInfo ||
+                !deviceBuildInfo ||
+                deviceBuildInfo.buildTime !== localBuildInfo.buildTime);
+        });
+    }
+    updateHashesOnDevice(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { device, appIdentifier, platformData, outputFilePath } = data;
+            if (!this.$mobileHelper.isAndroidPlatform(platformData.normalizedPlatformName)) {
+                return;
+            }
+            let hashes = {};
+            const hashesFilePath = path.join(outputFilePath, constants_1.HASHES_FILE_NAME);
+            if (this.$fs.exists(hashesFilePath)) {
+                hashes = this.$fs.readJson(hashesFilePath);
+            }
+            yield device.fileSystem.updateHashesOnDevice(hashes, appIdentifier);
+        });
+    }
+}
+exports.DeviceInstallAppService = DeviceInstallAppService;
+yok_1.injector.register("deviceInstallAppService", DeviceInstallAppService);

package/lib/services/doctor-service.js

@@ -0,0 +1,294 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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.DoctorService = void 0;
+const os_1 = require("os");
+const path = require("path");
+const _ = require("lodash");
+const helpers = require("../common/helpers");
+const decorators_1 = require("../common/decorators");
+const constants_1 = require("../constants");
+const doctor_1 = require("@nativescript/doctor");
+const yok_1 = require("../common/yok");
+const color_1 = require("../color");
+class DoctorService {
+    get jsonFileSettingsPath() {
+        return path.join(this.$settingsService.getProfileDir(), "doctor-cache.json");
+    }
+    get $jsonFileSettingsService() {
+        return this.$injector.resolve("jsonFileSettingsService", { jsonFileSettingsPath: this.jsonFileSettingsPath });
+    }
+    constructor($analyticsService, $hostInfo, $logger, $childProcess, $injector, $projectDataService, $fs, $terminalSpinnerService, $versionsService, $settingsService) {
+        this.$analyticsService = $analyticsService;
+        this.$hostInfo = $hostInfo;
+        this.$logger = $logger;
+        this.$childProcess = $childProcess;
+        this.$injector = $injector;
+        this.$projectDataService = $projectDataService;
+        this.$fs = $fs;
+        this.$terminalSpinnerService = $terminalSpinnerService;
+        this.$versionsService = $versionsService;
+        this.$settingsService = $settingsService;
+    }
+    printWarnings(configOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            configOptions = configOptions || {};
+            const getInfosData = {
+                projectDir: configOptions.projectDir,
+                androidRuntimeVersion: configOptions.runtimeVersion,
+                platform: configOptions.platform,
+            };
+            const infos = yield this.$terminalSpinnerService.execute({
+                text: `Getting environment information ${os_1.EOL}`,
+            }, () => this.getInfos({ forceCheck: configOptions.forceCheck }, getInfosData));
+            const warnings = infos.filter((info) => info.type === doctor_1.constants.WARNING_TYPE_NAME);
+            const hasWarnings = warnings.length > 0;
+            const hasAndroidWarnings = warnings.filter((warning) => _.includes(warning.platforms, doctor_1.constants.ANDROID_PLATFORM_NAME)).length > 0;
+            if (hasAndroidWarnings) {
+                this.printPackageManagerTip();
+            }
+            if (!configOptions || configOptions.trackResult) {
+            }
+            if (hasWarnings) {
+                this.$logger.info("There seem to be issues with your configuration.");
+                this.$fs.deleteFile(this.jsonFileSettingsPath);
+            }
+            else {
+                this.$logger.info(color_1.color.bold("No issues were detected."));
+                yield this.$jsonFileSettingsService.saveSetting(this.getKeyForConfiguration(getInfosData), infos);
+                this.printInfosCore(infos);
+            }
+            try {
+                yield this.$versionsService.printVersionsInformation(configOptions.platform);
+            }
+            catch (err) {
+                this.$logger.error("Cannot get the latest versions information from npm. Please try again later.");
+            }
+            this.checkForDeprecatedShortImportsInAppDir(configOptions.projectDir);
+            yield this.$injector
+                .resolve("platformEnvironmentRequirements")
+                .checkEnvironmentRequirements({
+                platform: configOptions.platform,
+                projectDir: configOptions.projectDir,
+                runtimeVersion: configOptions.runtimeVersion,
+                options: configOptions.options,
+            });
+        });
+    }
+    runSetupScript() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Run Setup Script",
+                additionalData: "Starting",
+            });
+            if (this.$hostInfo.isLinux) {
+                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                    action: "Run Setup Script",
+                    additionalData: "Skipped as OS is Linux",
+                });
+                return;
+            }
+            this.$logger.info("Running the setup script to try and automatically configure your environment.");
+            if (this.$hostInfo.isDarwin) {
+                yield this.runSetupScriptCore(DoctorService.DarwinSetupScriptLocation, []);
+            }
+            if (this.$hostInfo.isWindows) {
+                yield this.runSetupScriptCore(DoctorService.WindowsSetupScriptExecutable, DoctorService.WindowsSetupScriptArguments);
+            }
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Run Setup Script",
+                additionalData: "Finished",
+            });
+        });
+    }
+    canExecuteLocalBuild(configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Check Local Build Setup",
+                additionalData: "Starting",
+            });
+            const sysInfoConfig = {
+                platform: configuration.platform,
+                projectDir: configuration.projectDir,
+                androidRuntimeVersion: configuration.runtimeVersion,
+            };
+            const infos = yield this.getInfos({ forceCheck: configuration && configuration.forceCheck }, sysInfoConfig);
+            const warnings = this.filterInfosByType(infos, doctor_1.constants.WARNING_TYPE_NAME);
+            const hasWarnings = warnings.length > 0;
+            if (hasWarnings) {
+                this.$fs.deleteFile(this.jsonFileSettingsPath);
+                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                    action: "Check Local Build Setup",
+                    additionalData: `Warnings:${warnings.map((w) => w.message).join("__")}`,
+                });
+                this.printInfosCore(infos);
+            }
+            else {
+                infos.map((info) => this.$logger.trace(info.message));
+                yield this.$jsonFileSettingsService.saveSetting(this.getKeyForConfiguration(sysInfoConfig), infos);
+            }
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Check Local Build Setup",
+                additionalData: `Finished: Is setup correct: ${!hasWarnings}`,
+            });
+            return !hasWarnings;
+        });
+    }
+    checkForDeprecatedShortImportsInAppDir(projectDir) {
+        if (projectDir) {
+            try {
+                const files = this.$projectDataService.getAppExecutableFiles(projectDir);
+                const shortImports = this.getDeprecatedShortImportsInFiles(files, projectDir);
+                if (shortImports.length) {
+                    this.$logger.printMarkdown("Detected short imports in your application. Please note that `short imports are deprecated` since NativeScript 5.2.0. More information can be found in this blogpost https://www.nativescript.org/blog/say-goodbye-to-short-imports-in-nativescript");
+                    shortImports.forEach((shortImport) => {
+                        this.$logger.printMarkdown(`In file \`${shortImport.file}\` line \`${shortImport.line}\` is short import. Add \`tns-core-modules/\` in front of the required/imported module.`);
+                    });
+                }
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to validate if project has short imports. Error is`, err);
+            }
+        }
+    }
+    getDeprecatedShortImportsInFiles(files, projectDir) {
+        const shortImportRegExp = this.getShortImportRegExp(projectDir);
+        const shortImports = [];
+        for (const file of files) {
+            const fileContent = this.$fs.readText(file);
+            const strippedComments = helpers.stripComments(fileContent);
+            const linesToCheck = _.flatten(strippedComments.split(/\r?\n/).map((line) => line.split(";")));
+            const linesWithRequireStatements = linesToCheck.filter((line) => /\btns-core-modules\b/.exec(line) === null &&
+                (/\bimport\b/.exec(line) || /\brequire\b/.exec(line)));
+            for (const line of linesWithRequireStatements) {
+                const matches = line.match(shortImportRegExp);
+                if (matches && matches.length) {
+                    shortImports.push({ file, line });
+                }
+            }
+        }
+        return shortImports;
+    }
+    getShortImportRegExp(projectDir) {
+        const pathToTnsCoreModules = path.join(projectDir, constants_1.NODE_MODULES_FOLDER_NAME, constants_1.TNS_CORE_MODULES_NAME);
+        const coreModulesSubDirs = this.$fs
+            .readDirectory(pathToTnsCoreModules)
+            .filter((entry) => this.$fs
+            .getFsStats(path.join(pathToTnsCoreModules, entry))
+            .isDirectory());
+        const stringRegularExpressionsPerDir = coreModulesSubDirs.map((c) => {
+            const subDirPart = `[\"\']${c}[\"\'/]`;
+            return `(\\brequire\\s*?\\(\\s*?${subDirPart})|(\\bimport\\b.*?from\\s*?${subDirPart})`;
+        });
+        return new RegExp(stringRegularExpressionsPerDir.join("|"), "g");
+    }
+    runSetupScriptCore(executablePath, setupScriptArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$childProcess.spawnFromEvent(executablePath, setupScriptArgs, "close", { stdio: "inherit" });
+        });
+    }
+    printPackageManagerTip() {
+        if (this.$hostInfo.isWindows) {
+            this.$logger.info("TIP: To avoid setting up the necessary environment variables, you can use the chocolatey package manager to install the Android SDK and its dependencies." +
+                os_1.EOL);
+        }
+        else if (this.$hostInfo.isDarwin) {
+            this.$logger.info("TIP: To avoid setting up the necessary environment variables, you can use the Homebrew package manager to install the Android SDK and its dependencies." +
+                os_1.EOL);
+        }
+    }
+    printInfosCore(infos) {
+        if (!helpers.isInteractive()) {
+            infos.map((info) => {
+                let message = info.message;
+                if (info.type === doctor_1.constants.WARNING_TYPE_NAME) {
+                    message = `WARNING: ${color_1.color.yellow(info.message)} ${os_1.EOL} ${info.additionalInformation} ${os_1.EOL}`;
+                }
+                this.$logger.info(message);
+            });
+        }
+        infos
+            .filter((info) => info.type === doctor_1.constants.INFO_TYPE_NAME)
+            .map((info) => {
+            const spinner = this.$terminalSpinnerService.createSpinner();
+            spinner.text = info.message;
+            spinner.succeed();
+        });
+        infos
+            .filter((info) => info.type === doctor_1.constants.WARNING_TYPE_NAME)
+            .map((info) => {
+            const spinner = this.$terminalSpinnerService.createSpinner();
+            spinner.text = `${color_1.color.yellow(info.message)} ${os_1.EOL} ${info.additionalInformation} ${os_1.EOL}`;
+            spinner.fail();
+        });
+    }
+    filterInfosByType(infos, type) {
+        return infos.filter((info) => info.type === type);
+    }
+    getKeyForConfiguration(sysInfoConfig) {
+        const nativeScriptData = sysInfoConfig &&
+            sysInfoConfig.projectDir &&
+            JSON.stringify(this.$fs.readJson(path.join(sysInfoConfig.projectDir, "package.json"))
+                .nativescript);
+        const delimiter = "__";
+        const key = [
+            JSON.stringify(sysInfoConfig),
+            process.env.ANDROID_HOME,
+            process.env.JAVA_HOME,
+            process.env["CommonProgramFiles(x86)"],
+            process.env["CommonProgramFiles"],
+            process.env.PROCESSOR_ARCHITEW6432,
+            process.env.ProgramFiles,
+            process.env["ProgramFiles(x86)"],
+            nativeScriptData,
+        ]
+            .filter((a) => !!a)
+            .join(delimiter);
+        const data = helpers.getHash(key, { algorithm: "md5" });
+        return data;
+    }
+    getInfos(cacheConfig, sysInfoConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.getKeyForConfiguration(sysInfoConfig);
+            const infosFromCache = cacheConfig.forceCheck
+                ? null
+                : yield this.$jsonFileSettingsService.getSettingValue(key);
+            this.$logger.trace(`getInfos cacheConfig options:`, cacheConfig, " current info from cache: ", infosFromCache);
+            const infos = infosFromCache || (yield doctor_1.doctor.getInfos(sysInfoConfig));
+            return infos;
+        });
+    }
+}
+DoctorService.DarwinSetupScriptLocation = path.join(__dirname, "..", "..", "setup", "mac-startup-shell-script.sh");
+DoctorService.WindowsSetupScriptExecutable = "powershell.exe";
+DoctorService.WindowsSetupScriptArguments = [
+    "start-process",
+    "-FilePath",
+    "PowerShell.exe",
+    "-NoNewWindow",
+    "-Wait",
+    "-ArgumentList",
+    "\"-NoProfile -ExecutionPolicy Bypass -Command iex ((new-object net.webclient).DownloadString('https://www.nativescript.org/setup/win'))\"",
+];
+__decorate([
+    (0, decorators_1.cache)()
+], DoctorService.prototype, "jsonFileSettingsPath", null);
+__decorate([
+    (0, decorators_1.cache)()
+], DoctorService.prototype, "$jsonFileSettingsService", null);
+exports.DoctorService = DoctorService;
+yok_1.injector.register("doctorService", DoctorService);

package/lib/services/extensibility-service.js

@@ -0,0 +1,220 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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.ExtensibilityService = void 0;
+const path = require("path");
+const _ = require("lodash");
+const decorators_1 = require("../common/decorators");
+const constants = require("../constants");
+const helpers_1 = require("../common/helpers");
+const yok_1 = require("../common/yok");
+class ExtensibilityService {
+    get pathToPackageJson() {
+        return path.join(this.pathToExtensions, constants.PACKAGE_JSON_FILE_NAME);
+    }
+    get pathToExtensions() {
+        return (this.customPathToExtensions ||
+            path.join(this.$settingsService.getProfileDir(), "extensions"));
+    }
+    set pathToExtensions(pathToExtensions) {
+        this.customPathToExtensions = pathToExtensions;
+    }
+    constructor($fs, $logger, $packageManager, $settingsService, $requireService) {
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$packageManager = $packageManager;
+        this.$settingsService = $settingsService;
+        this.$requireService = $requireService;
+        this.customPathToExtensions = null;
+    }
+    installExtension(extensionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace(`Start installation of extension '${extensionName}'.`);
+            yield this.assertPackageJsonExists();
+            const npmOpts = {
+                save: true,
+                ["save-exact"]: true,
+            };
+            const localPath = path.resolve(extensionName);
+            const packageName = this.$fs.exists(localPath) ? localPath : extensionName;
+            const installResultInfo = yield this.$packageManager.install(packageName, this.pathToExtensions, npmOpts);
+            this.$logger.trace(`Finished installation of extension '${extensionName}'. Trying to load it now.`);
+            return this.getInstalledExtensionData(installResultInfo.name);
+        });
+    }
+    uninstallExtension(extensionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace(`Start uninstallation of extension '${extensionName}'.`);
+            yield this.assertPackageJsonExists();
+            yield this.$packageManager.uninstall(extensionName, { save: true }, this.pathToExtensions);
+            this.$logger.trace(`Finished uninstallation of extension '${extensionName}'.`);
+        });
+    }
+    removeAllExtensions() {
+        this.$fs.deleteDirectorySafe(this.pathToExtensions);
+        this.$logger.info(`Removed all NativeScript CLI extensions.`);
+    }
+    getInstalledExtensionsData() {
+        const installedExtensions = this.getInstalledExtensions();
+        return _.keys(installedExtensions).map((installedExtension) => this.getInstalledExtensionData(installedExtension));
+    }
+    loadExtensions() {
+        this.$logger.trace("Loading extensions.");
+        let dependencies = null;
+        try {
+            dependencies = this.getInstalledExtensions();
+        }
+        catch (err) {
+            this.$logger.trace(`Error while getting installed dependencies: ${err.message}. No extensions will be loaded.`);
+        }
+        return _.keys(dependencies).map((name) => this.loadExtension(name));
+    }
+    getInstalledExtensions() {
+        if (this.$fs.exists(this.pathToPackageJson)) {
+            return this.$fs.readJson(this.pathToPackageJson).dependencies;
+        }
+        return null;
+    }
+    getInstalledExtensionData(extensionName) {
+        const packageJsonData = this.getExtensionPackageJsonData(extensionName);
+        const pathToExtension = this.getPathToExtension(extensionName);
+        const docs = packageJsonData &&
+            packageJsonData.nativescript &&
+            packageJsonData.nativescript.docs &&
+            path.join(pathToExtension, packageJsonData.nativescript.docs);
+        return {
+            extensionName: packageJsonData.name,
+            version: packageJsonData.version,
+            docs,
+            pathToExtension,
+        };
+    }
+    loadExtension(extensionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.assertExtensionIsInstalled(extensionName);
+                const pathToExtension = this.getPathToExtension(extensionName);
+                this.$requireService.require(pathToExtension);
+                return this.getInstalledExtensionData(extensionName);
+            }
+            catch (error) {
+                this.$logger.warn(`Error while loading ${extensionName} is: ${error.message}`);
+                const err = (new Error(`Unable to load extension ${extensionName}. You will not be able to use the functionality that it adds. Error: ${error.message}`));
+                err.extensionName = extensionName;
+                throw err;
+            }
+        });
+    }
+    getExtensionNameWhereCommandIsRegistered(inputOpts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let allExtensions = [];
+            try {
+                const npmsResult = yield this.$packageManager.searchNpms("nativescript:extension");
+                allExtensions = npmsResult.results || [];
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to find extensions via npms. Error is: ${err}`);
+                return null;
+            }
+            const defaultCommandRegExp = new RegExp(`${(0, helpers_1.regExpEscape)(inputOpts.defaultCommandDelimiter)}.*`);
+            const commandDelimiterRegExp = (0, helpers_1.createRegExp)(inputOpts.commandDelimiter, "g");
+            for (const extensionData of allExtensions) {
+                const extensionName = extensionData.package.name;
+                try {
+                    const registryData = yield this.$packageManager.getRegistryPackageData(extensionName);
+                    const latestPackageData = registryData.versions[registryData["dist-tags"].latest];
+                    const commands = latestPackageData &&
+                        latestPackageData.nativescript &&
+                        latestPackageData.nativescript.commands;
+                    if (commands && commands.length) {
+                        _.filter(commands, (command) => command.indexOf(inputOpts.defaultCommandDelimiter) !== -1).forEach((defaultCommand) => {
+                            commands.push(defaultCommand.replace(defaultCommandRegExp, ""));
+                        });
+                        const copyOfFullArgs = _.clone(inputOpts.inputStrings);
+                        while (copyOfFullArgs.length) {
+                            const currentCommand = copyOfFullArgs
+                                .join(inputOpts.commandDelimiter)
+                                .toLowerCase();
+                            if (_.some(commands, (c) => c.toLowerCase() === currentCommand)) {
+                                const beautifiedCommandName = currentCommand.replace(commandDelimiterRegExp, " ");
+                                return {
+                                    extensionName,
+                                    registeredCommandName: currentCommand,
+                                    installationMessage: `The command ${beautifiedCommandName} is registered in extension ${extensionName}. You can install it by executing 'tns extension install ${extensionName}'`,
+                                };
+                            }
+                            copyOfFullArgs.splice(-1, 1);
+                        }
+                    }
+                }
+                catch (err) {
+                    this.$logger.trace(`Unable to get data for ${extensionName}. Error is: ${err}`);
+                }
+            }
+            return null;
+        });
+    }
+    getPathToExtension(extensionName) {
+        return path.join(this.pathToExtensions, constants.NODE_MODULES_FOLDER_NAME, extensionName);
+    }
+    getExtensionPackageJsonData(extensionName) {
+        const pathToExtension = this.getPathToExtension(extensionName);
+        const pathToPackageJson = path.join(pathToExtension, constants.PACKAGE_JSON_FILE_NAME);
+        const jsonData = this.$fs.readJson(pathToPackageJson);
+        return jsonData;
+    }
+    assertExtensionIsInstalled(extensionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace(`Asserting extension ${extensionName} is installed.`);
+            const installedExtensions = this.$fs.readDirectory(path.join(this.pathToExtensions, constants.NODE_MODULES_FOLDER_NAME));
+            if (installedExtensions.indexOf(extensionName) === -1) {
+                this.$logger.trace(`Extension ${extensionName} is not installed, starting installation.`);
+                yield this.installExtension(extensionName);
+            }
+            this.$logger.trace(`Extension ${extensionName} is installed.`);
+        });
+    }
+    assertExtensionsDirExists() {
+        if (!this.$fs.exists(this.pathToExtensions)) {
+            this.$fs.createDirectory(this.pathToExtensions);
+        }
+    }
+    assertPackageJsonExists() {
+        this.assertExtensionsDirExists();
+        if (!this.$fs.exists(this.pathToPackageJson)) {
+            this.$logger.trace(`Creating ${this.pathToPackageJson}.`);
+            this.$fs.writeJson(this.pathToPackageJson, {
+                name: "nativescript-extensibility",
+                version: "1.0.0",
+                description: "The place where all packages that extend CLI will be installed.",
+                license: "Apache-2.0",
+                readme: "The place where all packages that extend CLI will be installed.",
+                repository: "none",
+                dependencies: {},
+            });
+            this.$logger.trace(`Created ${this.pathToPackageJson}.`);
+        }
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], ExtensibilityService.prototype, "assertExtensionsDirExists", null);
+__decorate([
+    (0, decorators_1.cache)()
+], ExtensibilityService.prototype, "assertPackageJsonExists", null);
+exports.ExtensibilityService = ExtensibilityService;
+yok_1.injector.register("extensibilityService", ExtensibilityService);