@akylas/nativescript-cli 8.8.2 → 8.8.3

package/lib/node-package-manager.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodePackageManager = void 0;
 const path_1 = require("path");
@@ -29,114 +20,101 @@ class NodePackageManager extends base_package_manager_1.BasePackageManager {
         this.$logger = $logger;
         this.$httpClient = $httpClient;
     }
-    install(packageName, pathToSave, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (config.disableNpmInstall) {
-                return;
-            }
-            if (config.ignoreScripts) {
-                config["ignore-scripts"] = true;
-            }
-            const packageJsonPath = (0, path_1.join)(pathToSave, "package.json");
-            const jsonContentBefore = this.$fs.readJson(packageJsonPath);
-            const flags = this.getFlagsString(config, true);
-            let params = ["install", "--legacy-peer-deps"];
-            const isInstallingAllDependencies = packageName === pathToSave;
-            if (!isInstallingAllDependencies) {
-                params.push(packageName);
-            }
-            params = params.concat(flags);
-            const cwd = pathToSave;
-            const etcDirectoryLocation = (0, path_1.join)(cwd, "etc");
-            const etcExistsPriorToInstallation = this.$fs.exists(etcDirectoryLocation);
-            if (config.path) {
-                let relativePathFromCwdToSource = "";
-                if (config.frameworkPath) {
-                    relativePathFromCwdToSource = (0, path_1.relative)(config.frameworkPath, pathToSave);
-                    if (this.$fs.exists(relativePathFromCwdToSource)) {
-                        packageName = relativePathFromCwdToSource;
-                    }
+    async install(packageName, pathToSave, config) {
+        if (config.disableNpmInstall) {
+            return;
+        }
+        if (config.ignoreScripts) {
+            config["ignore-scripts"] = true;
+        }
+        const packageJsonPath = (0, path_1.join)(pathToSave, "package.json");
+        const jsonContentBefore = this.$fs.readJson(packageJsonPath);
+        const flags = this.getFlagsString(config, true);
+        let params = ["install", "--legacy-peer-deps"];
+        const isInstallingAllDependencies = packageName === pathToSave;
+        if (!isInstallingAllDependencies) {
+            params.push(packageName);
+        }
+        params = params.concat(flags);
+        const cwd = pathToSave;
+        const etcDirectoryLocation = (0, path_1.join)(cwd, "etc");
+        const etcExistsPriorToInstallation = this.$fs.exists(etcDirectoryLocation);
+        if (config.path) {
+            let relativePathFromCwdToSource = "";
+            if (config.frameworkPath) {
+                relativePathFromCwdToSource = (0, path_1.relative)(config.frameworkPath, pathToSave);
+                if (this.$fs.exists(relativePathFromCwdToSource)) {
+                    packageName = relativePathFromCwdToSource;
                 }
             }
-            try {
-                const result = yield this.processPackageManagerInstall(packageName, params, { cwd, isInstallingAllDependencies });
-                return result;
+        }
+        try {
+            const result = await this.processPackageManagerInstall(packageName, params, { cwd, isInstallingAllDependencies });
+            return result;
+        }
+        catch (err) {
+            if (err.message && err.message.indexOf("EPEERINVALID") !== -1) {
+                this.$logger.warn(err.message);
             }
-            catch (err) {
-                if (err.message && err.message.indexOf("EPEERINVALID") !== -1) {
-                    this.$logger.warn(err.message);
-                }
-                else {
-                    this.$fs.writeJson(packageJsonPath, jsonContentBefore);
-                    throw err;
-                }
+            else {
+                this.$fs.writeJson(packageJsonPath, jsonContentBefore);
+                throw err;
             }
-            finally {
-                if (!etcExistsPriorToInstallation) {
-                    this.$fs.deleteDirectory(etcDirectoryLocation);
-                }
+        }
+        finally {
+            if (!etcExistsPriorToInstallation) {
+                this.$fs.deleteDirectory(etcDirectoryLocation);
             }
-        });
+        }
     }
-    uninstall(packageName, config, path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const flags = this.getFlagsString(config, false);
-            return this.$childProcess.exec(`npm uninstall ${packageName} ${flags}`, {
-                cwd: path,
-            });
+    async uninstall(packageName, config, path) {
+        const flags = this.getFlagsString(config, false);
+        return this.$childProcess.exec(`npm uninstall ${packageName} ${flags}`, {
+            cwd: path,
         });
     }
-    search(filter, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const flags = this.getFlagsString(config, false);
-            return this.$childProcess.exec(`npm search ${filter.join(" ")} ${flags}`);
-        });
+    async search(filter, config) {
+        const flags = this.getFlagsString(config, false);
+        return this.$childProcess.exec(`npm search ${filter.join(" ")} ${flags}`);
     }
-    view(packageName, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const wrappedConfig = _.extend({}, config, { json: true });
-            const flags = this.getFlagsString(wrappedConfig, false);
-            let viewResult;
-            try {
-                viewResult = yield this.$childProcess.exec(`npm view ${packageName} ${flags}`);
-            }
-            catch (e) {
-                this.$errors.fail(e.message);
-            }
-            try {
-                return JSON.parse(viewResult);
-            }
-            catch (err) {
-                return null;
-            }
-        });
+    async view(packageName, config) {
+        const wrappedConfig = _.extend({}, config, { json: true });
+        const flags = this.getFlagsString(wrappedConfig, false);
+        let viewResult;
+        try {
+            viewResult = await this.$childProcess.exec(`npm view ${packageName} ${flags}`);
+        }
+        catch (e) {
+            this.$errors.fail(e.message);
+        }
+        try {
+            return JSON.parse(viewResult);
+        }
+        catch (err) {
+            return null;
+        }
     }
-    searchNpms(keyword) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const httpRequestResult = yield this.$httpClient.httpRequest(`https://api.npms.io/v2/search?q=keywords:${keyword}`);
-            const result = JSON.parse(httpRequestResult.body);
-            return result;
-        });
+    async searchNpms(keyword) {
+        const httpRequestResult = await this.$httpClient.httpRequest(`https://api.npms.io/v2/search?q=keywords:${keyword}`);
+        const result = JSON.parse(httpRequestResult.body);
+        return result;
     }
-    getRegistryPackageData(packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const registry = yield this.$childProcess.exec(`npm config get registry`);
-            const url = registry.trim() + packageName;
-            this.$logger.trace(`Trying to get data from npm registry for package ${packageName}, url is: ${url}`);
-            const responseData = (yield this.$httpClient.httpRequest(url)).body;
-            this.$logger.trace(`Successfully received data from npm registry for package ${packageName}. Response data is: ${responseData}`);
-            const jsonData = JSON.parse(responseData);
-            this.$logger.trace(`Successfully parsed data from npm registry for package ${packageName}.`);
-            return jsonData;
-        });
+    async getRegistryPackageData(packageName) {
+        const registry = await this.$childProcess.exec(`npm config get registry`);
+        const url = registry.trim() + packageName;
+        this.$logger.trace(`Trying to get data from npm registry for package ${packageName}, url is: ${url}`);
+        const responseData = (await this.$httpClient.httpRequest(url)).body;
+        this.$logger.trace(`Successfully received data from npm registry for package ${packageName}. Response data is: ${responseData}`);
+        const jsonData = JSON.parse(responseData);
+        this.$logger.trace(`Successfully parsed data from npm registry for package ${packageName}.`);
+        return jsonData;
     }
-    getCachePath() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cachePath = yield this.$childProcess.exec(`npm config get cache`);
-            return (0, path_1.join)(cachePath.trim(), constants_1.CACACHE_DIRECTORY_NAME);
-        });
+    async getCachePath() {
+        const cachePath = await this.$childProcess.exec(`npm config get cache`);
+        return (0, path_1.join)(cachePath.trim(), constants_1.CACACHE_DIRECTORY_NAME);
     }
 }
+exports.NodePackageManager = NodePackageManager;
 __decorate([
     (0, decorators_1.exported)("npm")
 ], NodePackageManager.prototype, "install", null);
@@ -152,5 +130,4 @@ __decorate([
 __decorate([
     (0, decorators_1.cache)()
 ], NodePackageManager.prototype, "getCachePath", null);
-exports.NodePackageManager = NodePackageManager;
 yok_1.injector.register("npm", NodePackageManager);

package/lib/options.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Options = void 0;
 const helpers = require("./common/helpers");
@@ -323,7 +314,7 @@ class Options {
         const parsed = yargs((0, helpers_1.hideBin)(process.argv))
             .version(false)
             .help(false)
-            .completion("completion_generate_script", (current_, argv) => __awaiter(this, void 0, void 0, function* () {
+            .completion("completion_generate_script", async (current_, argv) => {
             var _a;
             const args = argv._.slice(1);
             const commands = yok_1.injector
@@ -351,7 +342,7 @@ class Options {
                 return this.shorthands.map((o) => `-${o}`);
             }
             return completions;
-        }));
+        });
         this.initialArgv = parsed.argv;
         this.argv = parsed.options(opts).argv;
         this.$settingsService.setSettings({
@@ -394,7 +385,7 @@ class Options {
         });
     }
 }
+exports.Options = Options;
 Options.DASHED_OPTION_REGEX = /(.+?)([A-Z])(.*)/;
 Options.NONDASHED_OPTION_REGEX = /(.+?)[-]([a-zA-Z])(.*)/;
-exports.Options = Options;
 yok_1.injector.register("options", Options);

package/lib/package-installation-manager.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackageInstallationManager = void 0;
 const path = require("path");
@@ -24,139 +15,119 @@ class PackageInstallationManager {
         this.$staticConfig = $staticConfig;
         this.$projectDataService = $projectDataService;
     }
-    getLatestVersion(packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.getVersion(packageName, constants.PackageVersion.LATEST);
-        });
-    }
-    getNextVersion(packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.getVersion(packageName, constants.PackageVersion.NEXT);
-        });
-    }
-    getLatestCompatibleVersion(packageName, referenceVersion) {
-        return __awaiter(this, void 0, void 0, function* () {
-            referenceVersion = referenceVersion || this.$staticConfig.version;
-            const isPreReleaseVersion = semver.prerelease(referenceVersion) !== null;
-            const compatibleVersionRange = isPreReleaseVersion
-                ? `~${referenceVersion}`
-                : `~${semver.major(referenceVersion)}.${semver.minor(referenceVersion)}.0`;
-            const latestVersion = yield this.getLatestVersion(packageName);
-            if (semver.satisfies(latestVersion, compatibleVersionRange)) {
-                return latestVersion;
-            }
-            return ((yield this.getMaxSatisfyingVersion(packageName, compatibleVersionRange)) || latestVersion);
-        });
+    async getLatestVersion(packageName) {
+        return await this.getVersion(packageName, constants.PackageVersion.LATEST);
+    }
+    async getNextVersion(packageName) {
+        return await this.getVersion(packageName, constants.PackageVersion.NEXT);
+    }
+    async getLatestCompatibleVersion(packageName, referenceVersion) {
+        referenceVersion = referenceVersion || this.$staticConfig.version;
+        const isPreReleaseVersion = semver.prerelease(referenceVersion) !== null;
+        const compatibleVersionRange = isPreReleaseVersion
+            ? `~${referenceVersion}`
+            : `~${semver.major(referenceVersion)}.${semver.minor(referenceVersion)}.0`;
+        const latestVersion = await this.getLatestVersion(packageName);
+        if (semver.satisfies(latestVersion, compatibleVersionRange)) {
+            return latestVersion;
+        }
+        return ((await this.getMaxSatisfyingVersion(packageName, compatibleVersionRange)) || latestVersion);
     }
-    getMaxSatisfyingVersion(packageName, versionRange) {
+    async getMaxSatisfyingVersion(packageName, versionRange) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.$packageManager.view(packageName, {
-                versions: true,
-            });
-            let versions;
-            if (typeof data === "string") {
-                versions = [data];
-            }
-            else if (data === null || data === void 0 ? void 0 : data.versions) {
-                versions = data.versions;
-            }
-            else {
-                versions = data;
-            }
-            if (!versions || !Array.isArray(versions)) {
-                return null;
-            }
-            return (_a = semver.maxSatisfying(versions, versionRange)) === null || _a === void 0 ? void 0 : _a.toString();
-        });
-    }
-    getMaxSatisfyingVersionSafe(packageName, versionIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let maxDependencyVersion;
-            if (semver.valid(versionIdentifier)) {
-                maxDependencyVersion = versionIdentifier;
-            }
-            else if (semver.validRange(versionIdentifier)) {
-                maxDependencyVersion = yield this.getMaxSatisfyingVersion(packageName, versionIdentifier);
-            }
-            else {
-                maxDependencyVersion = yield this.$packageManager.getTagVersion(packageName, versionIdentifier);
-            }
-            return maxDependencyVersion;
-        });
-    }
-    getInstalledDependencyVersion(packageName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const projectData = this.$projectDataService.getProjectData(projectDir);
-            const devDependencies = projectData.devDependencies || {};
-            const dependencies = projectData.dependencies || {};
-            const referencedVersion = dependencies[packageName] || devDependencies[packageName];
-            const installedVersion = yield this.getMaxSatisfyingVersionSafe(packageName, referencedVersion);
-            return installedVersion;
+        const data = await this.$packageManager.view(packageName, {
+            versions: true,
         });
+        let versions;
+        if (typeof data === "string") {
+            versions = [data];
+        }
+        else if (data === null || data === void 0 ? void 0 : data.versions) {
+            versions = data.versions;
+        }
+        else {
+            versions = data;
+        }
+        if (!versions || !Array.isArray(versions)) {
+            return null;
+        }
+        return (_a = semver.maxSatisfying(versions, versionRange)) === null || _a === void 0 ? void 0 : _a.toString();
     }
-    getLatestCompatibleVersionSafe(packageName, referenceVersion) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let version = "";
-            const canGetVersionFromNpm = yield this.$packageManager.isRegistered(packageName);
-            if (canGetVersionFromNpm) {
-                version = yield this.getLatestCompatibleVersion(packageName, referenceVersion);
-            }
-            return version;
-        });
+    async getMaxSatisfyingVersionSafe(packageName, versionIdentifier) {
+        let maxDependencyVersion;
+        if (semver.valid(versionIdentifier)) {
+            maxDependencyVersion = versionIdentifier;
+        }
+        else if (semver.validRange(versionIdentifier)) {
+            maxDependencyVersion = await this.getMaxSatisfyingVersion(packageName, versionIdentifier);
+        }
+        else {
+            maxDependencyVersion = await this.$packageManager.getTagVersion(packageName, versionIdentifier);
+        }
+        return maxDependencyVersion;
+    }
+    async getInstalledDependencyVersion(packageName, projectDir) {
+        const projectData = this.$projectDataService.getProjectData(projectDir);
+        const devDependencies = projectData.devDependencies || {};
+        const dependencies = projectData.dependencies || {};
+        const referencedVersion = dependencies[packageName] || devDependencies[packageName];
+        const installedVersion = await this.getMaxSatisfyingVersionSafe(packageName, referencedVersion);
+        return installedVersion;
+    }
+    async getLatestCompatibleVersionSafe(packageName, referenceVersion) {
+        let version = "";
+        const canGetVersionFromNpm = await this.$packageManager.isRegistered(packageName);
+        if (canGetVersionFromNpm) {
+            version = await this.getLatestCompatibleVersion(packageName, referenceVersion);
+        }
+        return version;
+    }
+    async install(packageToInstall, projectDir, opts) {
+        try {
+            const pathToSave = projectDir;
+            const version = (opts && opts.version) || null;
+            const dependencyType = (opts && opts.dependencyType) || null;
+            return await this.installCore(packageToInstall, pathToSave, version, dependencyType);
+        }
+        catch (error) {
+            this.$logger.trace(error);
+            throw error;
+        }
     }
-    install(packageToInstall, projectDir, opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const pathToSave = projectDir;
-                const version = (opts && opts.version) || null;
-                const dependencyType = (opts && opts.dependencyType) || null;
-                return yield this.installCore(packageToInstall, pathToSave, version, dependencyType);
-            }
-            catch (error) {
-                this.$logger.trace(error);
-                throw error;
-            }
-        });
+    async uninstall(packageToUninstall, projectDir, opts) {
+        try {
+            return await this.$packageManager.uninstall(packageToUninstall, opts, projectDir);
+        }
+        catch (error) {
+            this.$logger.trace(error);
+            throw error;
+        }
     }
-    uninstall(packageToUninstall, projectDir, opts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async getInspectorFromCache(inspectorNpmPackageName, projectDir) {
+        const inspectorPath = path.join(projectDir, constants.NODE_MODULES_FOLDER_NAME, inspectorNpmPackageName);
+        if (this.inspectorAlreadyInstalled(inspectorPath)) {
+            return inspectorPath;
+        }
+        const cachePath = this.getInspectorCachePath();
+        this.prepareCacheDir(cachePath);
+        const pathToPackageInCache = path.join(cachePath, constants.NODE_MODULES_FOLDER_NAME, inspectorNpmPackageName);
+        const iOSFrameworkNSValue = this.$projectDataService.getRuntimePackage(projectDir, "ios");
+        const version = await this.getLatestCompatibleVersion(inspectorNpmPackageName, iOSFrameworkNSValue.version);
+        let shouldInstall = !this.$fs.exists(pathToPackageInCache);
+        if (!shouldInstall) {
             try {
-                return yield this.$packageManager.uninstall(packageToUninstall, opts, projectDir);
+                const installedVersion = this.$fs.readJson(path.join(pathToPackageInCache, constants.PACKAGE_JSON_FILE_NAME)).version;
+                shouldInstall = version !== installedVersion;
             }
-            catch (error) {
-                this.$logger.trace(error);
-                throw error;
-            }
-        });
-    }
-    getInspectorFromCache(inspectorNpmPackageName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inspectorPath = path.join(projectDir, constants.NODE_MODULES_FOLDER_NAME, inspectorNpmPackageName);
-            if (this.inspectorAlreadyInstalled(inspectorPath)) {
-                return inspectorPath;
+            catch (err) {
+                shouldInstall = true;
             }
-            const cachePath = this.getInspectorCachePath();
-            this.prepareCacheDir(cachePath);
-            const pathToPackageInCache = path.join(cachePath, constants.NODE_MODULES_FOLDER_NAME, inspectorNpmPackageName);
-            const iOSFrameworkNSValue = this.$projectDataService.getRuntimePackage(projectDir, "ios");
-            const version = yield this.getLatestCompatibleVersion(inspectorNpmPackageName, iOSFrameworkNSValue.version);
-            let shouldInstall = !this.$fs.exists(pathToPackageInCache);
-            if (!shouldInstall) {
-                try {
-                    const installedVersion = this.$fs.readJson(path.join(pathToPackageInCache, constants.PACKAGE_JSON_FILE_NAME)).version;
-                    shouldInstall = version !== installedVersion;
-                }
-                catch (err) {
-                    shouldInstall = true;
-                }
-            }
-            if (shouldInstall) {
-                yield this.$childProcess.exec(`npm install ${inspectorNpmPackageName}@${version} --prefix ${cachePath}`, { maxBuffer: 250 * 1024 });
-            }
-            this.$logger.info("Using inspector from cache.");
-            return pathToPackageInCache;
-        });
+        }
+        if (shouldInstall) {
+            await this.$childProcess.exec(`npm install ${inspectorNpmPackageName}@${version} --prefix ${cachePath}`, { maxBuffer: 250 * 1024 });
+        }
+        this.$logger.info("Using inspector from cache.");
+        return pathToPackageInCache;
     }
     clearInspectorCache() {
         this.$fs.deleteDirectorySafe(this.getInspectorCachePath());
@@ -180,41 +151,35 @@ class PackageInstallationManager {
         }
         return false;
     }
-    installCore(packageName, pathToSave, version, dependencyType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const possiblePackageName = path.resolve(packageName);
-            if (this.$fs.exists(possiblePackageName)) {
-                packageName = possiblePackageName;
-            }
-            version =
-                version || (yield this.getLatestCompatibleVersionSafe(packageName));
-            const installResultInfo = yield this.npmInstall(packageName, pathToSave, version, dependencyType);
-            const installedPackageName = installResultInfo.name;
-            const pathToInstalledPackage = path.join(pathToSave, "node_modules", installedPackageName);
-            return pathToInstalledPackage;
-        });
-    }
-    npmInstall(packageName, pathToSave, version, dependencyType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.info(`Installing ${packageName}`);
-            packageName = packageName + (version ? `@${version}` : "");
-            const npmOptions = { silent: true, "save-exact": true };
-            if (dependencyType) {
-                npmOptions[dependencyType] = true;
-            }
-            return yield this.$packageManager.install(packageName, pathToSave, npmOptions);
-        });
+    async installCore(packageName, pathToSave, version, dependencyType) {
+        const possiblePackageName = path.resolve(packageName);
+        if (this.$fs.exists(possiblePackageName)) {
+            packageName = possiblePackageName;
+        }
+        version =
+            version || (await this.getLatestCompatibleVersionSafe(packageName));
+        const installResultInfo = await this.npmInstall(packageName, pathToSave, version, dependencyType);
+        const installedPackageName = installResultInfo.name;
+        const pathToInstalledPackage = path.join(pathToSave, "node_modules", installedPackageName);
+        return pathToInstalledPackage;
+    }
+    async npmInstall(packageName, pathToSave, version, dependencyType) {
+        this.$logger.info(`Installing ${packageName}`);
+        packageName = packageName + (version ? `@${version}` : "");
+        const npmOptions = { silent: true, "save-exact": true };
+        if (dependencyType) {
+            npmOptions[dependencyType] = true;
+        }
+        return await this.$packageManager.install(packageName, pathToSave, npmOptions);
     }
-    getVersion(packageName, version) {
+    async getVersion(packageName, version) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let data = yield this.$packageManager.view(packageName, {
-                "dist-tags": true,
-            });
-            data = (_a = data === null || data === void 0 ? void 0 : data["dist-tags"]) !== null && _a !== void 0 ? _a : data;
-            this.$logger.trace("Using version %s. ", data[version]);
-            return data[version];
+        let data = await this.$packageManager.view(packageName, {
+            "dist-tags": true,
         });
+        data = (_a = data === null || data === void 0 ? void 0 : data["dist-tags"]) !== null && _a !== void 0 ? _a : data;
+        this.$logger.trace("Using version %s. ", data[version]);
+        return data[version];
     }
 }
 exports.PackageInstallationManager = PackageInstallationManager;