@akylas/nativescript-cli 8.7.2

package/lib/package-installation-manager.js

@@ -0,0 +1,221 @@
+"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");
+const constants = require("./constants");
+const yok_1 = require("./common/yok");
+const semver = require("semver");
+class PackageInstallationManager {
+    constructor($packageManager, $childProcess, $logger, $settingsService, $fs, $staticConfig, $projectDataService) {
+        this.$packageManager = $packageManager;
+        this.$childProcess = $childProcess;
+        this.$logger = $logger;
+        this.$settingsService = $settingsService;
+        this.$fs = $fs;
+        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);
+        });
+    }
+    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;
+        });
+    }
+    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;
+        });
+    }
+    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;
+            }
+        });
+    }
+    uninstall(packageToUninstall, projectDir, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.$packageManager.uninstall(packageToUninstall, opts, projectDir);
+            }
+            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;
+            }
+            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;
+        });
+    }
+    clearInspectorCache() {
+        this.$fs.deleteDirectorySafe(this.getInspectorCachePath());
+    }
+    getInspectorCachePath() {
+        return path.join(this.$settingsService.getProfileDir(), constants.INSPECTOR_CACHE_DIRNAME);
+    }
+    prepareCacheDir(cacheDirName) {
+        this.$fs.ensureDirectoryExists(cacheDirName);
+        const cacheDirPackageJsonLocation = path.join(cacheDirName, constants.PACKAGE_JSON_FILE_NAME);
+        if (!this.$fs.exists(cacheDirPackageJsonLocation)) {
+            this.$fs.writeJson(cacheDirPackageJsonLocation, {
+                name: constants.INSPECTOR_CACHE_DIRNAME,
+                version: "0.1.0",
+            });
+        }
+    }
+    inspectorAlreadyInstalled(pathToInspector) {
+        if (this.$fs.exists(pathToInspector)) {
+            return true;
+        }
+        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);
+        });
+    }
+    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];
+        });
+    }
+}
+exports.PackageInstallationManager = PackageInstallationManager;
+yok_1.injector.register("packageInstallationManager", PackageInstallationManager);

package/lib/package-manager.js

@@ -0,0 +1,184 @@
+"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.PackageManager = void 0;
+const decorators_1 = require("./common/decorators");
+const decorators_2 = require("./common/decorators");
+const constants_1 = require("./constants");
+const yok_1 = require("./common/yok");
+class PackageManager {
+    constructor($errors, $npm, $options, $yarn, $yarn2, $pnpm, $bun, $logger, $userSettingsService, $projectConfigService) {
+        this.$errors = $errors;
+        this.$npm = $npm;
+        this.$options = $options;
+        this.$yarn = $yarn;
+        this.$yarn2 = $yarn2;
+        this.$pnpm = $pnpm;
+        this.$bun = $bun;
+        this.$logger = $logger;
+        this.$userSettingsService = $userSettingsService;
+        this.$projectConfigService = $projectConfigService;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.packageManager = yield this._determinePackageManager();
+        });
+    }
+    getPackageManagerName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._packageManagerName;
+        });
+    }
+    install(packageName, pathToSave, config) {
+        return this.packageManager.install(packageName, pathToSave, config);
+    }
+    uninstall(packageName, config, path) {
+        return this.packageManager.uninstall(packageName, config, path);
+    }
+    view(packageName, config) {
+        return this.packageManager.view(packageName, config);
+    }
+    search(filter, config) {
+        return this.packageManager.search(filter, config);
+    }
+    searchNpms(keyword) {
+        return this.packageManager.searchNpms(keyword);
+    }
+    isRegistered(packageName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.packageManager.isRegistered(packageName);
+        });
+    }
+    getPackageFullName(packageNameParts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.packageManager.getPackageFullName(packageNameParts);
+        });
+    }
+    getPackageNameParts(fullPackageName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.packageManager.getPackageNameParts(fullPackageName);
+        });
+    }
+    getRegistryPackageData(packageName) {
+        return this.packageManager.getRegistryPackageData(packageName);
+    }
+    getCachePath() {
+        return this.packageManager.getCachePath();
+    }
+    getTagVersion(packageName, tag) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let version = null;
+            if (!tag) {
+                return null;
+            }
+            try {
+                const result = yield this.view(packageName, { "dist-tags": true });
+                version = result[tag];
+            }
+            catch (err) {
+                this.$logger.trace(`Error while getting tag version from view command: ${err}`);
+                const registryData = yield this.getRegistryPackageData(packageName);
+                version = registryData["dist-tags"][tag];
+            }
+            return version;
+        });
+    }
+    _determinePackageManager() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let pm = null;
+            try {
+                pm = yield this.$userSettingsService.getSettingValue("packageManager");
+            }
+            catch (err) {
+                this.$errors.fail(`Unable to read package manager config from user settings ${err}`);
+            }
+            try {
+                const configPm = this.$projectConfigService.getValue("cli.packageManager");
+                if (configPm) {
+                    this.$logger.trace(`Determined packageManager to use from user config is: ${configPm}`);
+                    pm = configPm;
+                }
+            }
+            catch (err) {
+                this.$logger.trace("Tried to read cli.packageManager from project config and failed. Error is: ", err);
+            }
+            if (pm === constants_1.PackageManagers.yarn || this.$options.yarn) {
+                this._packageManagerName = constants_1.PackageManagers.yarn;
+                return this.$yarn;
+            }
+            if (pm === constants_1.PackageManagers.yarn2 || this.$options.yarn2) {
+                this._packageManagerName = constants_1.PackageManagers.yarn2;
+                return this.$yarn2;
+            }
+            else if (pm === constants_1.PackageManagers.pnpm || this.$options.pnpm) {
+                this._packageManagerName = constants_1.PackageManagers.pnpm;
+                return this.$pnpm;
+            }
+            else if (pm === constants_1.PackageManagers.bun) {
+                this._packageManagerName = constants_1.PackageManagers.bun;
+                return this.$bun;
+            }
+            else {
+                this._packageManagerName = constants_1.PackageManagers.npm;
+                return this.$npm;
+            }
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], PackageManager.prototype, "init", null);
+__decorate([
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "getPackageManagerName", null);
+__decorate([
+    (0, decorators_1.exported)("packageManager"),
+    (0, decorators_2.performanceLog)(),
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "install", null);
+__decorate([
+    (0, decorators_1.exported)("packageManager"),
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "uninstall", null);
+__decorate([
+    (0, decorators_1.exported)("packageManager"),
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "view", null);
+__decorate([
+    (0, decorators_1.exported)("packageManager"),
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "search", null);
+__decorate([
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "searchNpms", null);
+__decorate([
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "isRegistered", null);
+__decorate([
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "getPackageFullName", null);
+__decorate([
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "getPackageNameParts", null);
+__decorate([
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "getRegistryPackageData", null);
+__decorate([
+    (0, decorators_1.invokeInit)()
+], PackageManager.prototype, "getCachePath", null);
+exports.PackageManager = PackageManager;
+yok_1.injector.register("packageManager", PackageManager);

package/lib/platform-command-param.js

@@ -0,0 +1,29 @@
+"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.PlatformCommandParameter = void 0;
+const yok_1 = require("./common/yok");
+class PlatformCommandParameter {
+    constructor($platformValidationService, $projectData) {
+        this.$platformValidationService = $platformValidationService;
+        this.$projectData = $projectData;
+        this.mandatory = true;
+    }
+    validate(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$projectData.initializeProjectData();
+            this.$platformValidationService.validatePlatform(value, this.$projectData);
+            return true;
+        });
+    }
+}
+exports.PlatformCommandParameter = PlatformCommandParameter;
+yok_1.injector.register("platformCommandParameter", PlatformCommandParameter);

package/lib/pnpm-package-manager.js

@@ -0,0 +1,136 @@
+"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.PnpmPackageManager = void 0;
+const path = require("path");
+const _ = require("lodash");
+const base_package_manager_1 = require("./base-package-manager");
+const decorators_1 = require("./common/decorators");
+const constants_1 = require("./constants");
+const yok_1 = require("./common/yok");
+class PnpmPackageManager extends base_package_manager_1.BasePackageManager {
+    constructor($childProcess, $errors, $fs, $hostInfo, $httpClient, $logger, $pacoteService) {
+        super($childProcess, $fs, $hostInfo, $pacoteService, "pnpm");
+        this.$errors = $errors;
+        this.$httpClient = $httpClient;
+        this.$logger = $logger;
+    }
+    install(packageName, pathToSave, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (config.disableNpmInstall) {
+                return;
+            }
+            delete config.dev;
+            if (config.ignoreScripts) {
+                config["ignore-scripts"] = true;
+            }
+            const packageJsonPath = path.join(pathToSave, "package.json");
+            const jsonContentBefore = this.$fs.readJson(packageJsonPath);
+            const flags = this.getFlagsString(config, true);
+            let params = ["i", "--shamefully-hoist"];
+            const isInstallingAllDependencies = packageName === pathToSave;
+            if (!isInstallingAllDependencies) {
+                params.push(packageName);
+            }
+            params = params.concat(flags);
+            const cwd = pathToSave;
+            try {
+                const result = yield this.processPackageManagerInstall(packageName, params, { cwd, isInstallingAllDependencies });
+                return result;
+            }
+            catch (e) {
+                this.$fs.writeJson(packageJsonPath, jsonContentBefore);
+                throw e;
+            }
+        });
+    }
+    uninstall(packageName, config, cwd) {
+        delete config["save"];
+        const flags = this.getFlagsString(config, false);
+        return this.$childProcess.exec(`pnpm remove ${packageName} ${flags}`, {
+            cwd,
+        });
+    }
+    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(`pnpm info ${packageName} ${flags}`);
+            }
+            catch (e) {
+                this.$errors.fail(e.message);
+            }
+            try {
+                return JSON.parse(viewResult);
+            }
+            catch (err) {
+                return null;
+            }
+        });
+    }
+    search(filter, config) {
+        const flags = this.getFlagsString(config, false);
+        return this.$childProcess.exec(`pnpm search ${filter.join(" ")} ${flags}`);
+    }
+    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;
+        });
+    }
+    getRegistryPackageData(packageName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const registry = yield this.$childProcess.exec(`pnpm config get registry`);
+            const url = `${registry.trim()}/${packageName}`;
+            this.$logger.trace(`Trying to get data from pnpm registry for package ${packageName}, url is: ${url}`);
+            const responseData = (yield this.$httpClient.httpRequest(url)).body;
+            this.$logger.trace(`Successfully received data from pnpm registry for package ${packageName}. Response data is: ${responseData}`);
+            const jsonData = JSON.parse(responseData);
+            this.$logger.trace(`Successfully parsed data from pnpm registry for package ${packageName}.`);
+            return jsonData;
+        });
+    }
+    getCachePath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cachePath = yield this.$childProcess.exec(`pnpm config get cache`);
+            return path.join(cachePath.trim(), constants_1.CACACHE_DIRECTORY_NAME);
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.exported)("pnpm")
+], PnpmPackageManager.prototype, "install", null);
+__decorate([
+    (0, decorators_1.exported)("pnpm")
+], PnpmPackageManager.prototype, "uninstall", null);
+__decorate([
+    (0, decorators_1.exported)("pnpm")
+], PnpmPackageManager.prototype, "view", null);
+__decorate([
+    (0, decorators_1.exported)("pnpm")
+], PnpmPackageManager.prototype, "search", null);
+__decorate([
+    (0, decorators_1.exported)("pnpm")
+], PnpmPackageManager.prototype, "getRegistryPackageData", null);
+__decorate([
+    (0, decorators_1.exported)("pnpm")
+], PnpmPackageManager.prototype, "getCachePath", null);
+exports.PnpmPackageManager = PnpmPackageManager;
+yok_1.injector.register("pnpm", PnpmPackageManager);