@ts-dev-tools/core 1.12.1 → 1.12.2

package/dist/services/PackageManagerService.js

@@ -1,97 +1,42 @@
 "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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackageManagerService = exports.PackageManagerType = void 0;
-var fs_1 = require("fs");
-var path_1 = require("path");
-var NpmPackageManagerAdapter_1 = require("./package-manager/NpmPackageManagerAdapter");
-var PackageManagerType_1 = require("./package-manager/PackageManagerType");
-var YarnPackageManagerAdapter_1 = require("./package-manager/YarnPackageManagerAdapter");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const NpmPackageManagerAdapter_1 = require("./package-manager/NpmPackageManagerAdapter");
+const PackageManagerType_1 = require("./package-manager/PackageManagerType");
+const YarnPackageManagerAdapter_1 = require("./package-manager/YarnPackageManagerAdapter");
 var PackageManagerType_2 = require("./package-manager/PackageManagerType");
 Object.defineProperty(exports, "PackageManagerType", { enumerable: true, get: function () { return PackageManagerType_2.PackageManagerType; } });
-var PackageManagerService = /** @class */ (function () {
-    function PackageManagerService() {
-    }
-    PackageManagerService.detectPackageManager = function (dirPath) {
+class PackageManagerService {
+    static detectPackageManager(dirPath) {
         if ((0, fs_1.existsSync)((0, path_1.join)(dirPath, "yarn.lock"))) {
             return PackageManagerType_1.PackageManagerType.yarn;
         }
         return PackageManagerType_1.PackageManagerType.npm;
-    };
-    PackageManagerService.addDevPackage = function (packageName, dirPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).addDevPackage(packageName, dirPath)];
-            });
-        });
-    };
-    PackageManagerService.isMonorepo = function (dirPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).isMonorepo(dirPath)];
-            });
-        });
-    };
-    PackageManagerService.isPackageInstalled = function (packageName, dirPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).isPackageInstalled(packageName, dirPath)];
-            });
-        });
-    };
-    PackageManagerService.getNodeModulesPath = function (dirPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).getNodeModulesPath(dirPath)];
-            });
-        });
-    };
-    PackageManagerService.getAdapter = function (dirPath) {
-        var packageManager = PackageManagerService.detectPackageManager(dirPath);
+    }
+    static async addDevPackage(packageName, dirPath) {
+        return PackageManagerService.getAdapter(dirPath).addDevPackage(packageName, dirPath);
+    }
+    static async isMonorepo(dirPath) {
+        return PackageManagerService.getAdapter(dirPath).isMonorepo(dirPath);
+    }
+    static async isPackageInstalled(packageName, dirPath) {
+        return PackageManagerService.getAdapter(dirPath).isPackageInstalled(packageName, dirPath);
+    }
+    static async getNodeModulesPath(dirPath) {
+        return PackageManagerService.getAdapter(dirPath).getNodeModulesPath(dirPath);
+    }
+    static getAdapter(dirPath) {
+        const packageManager = PackageManagerService.detectPackageManager(dirPath);
         switch (packageManager) {
             case PackageManagerType_1.PackageManagerType.yarn:
                 return new YarnPackageManagerAdapter_1.YarnPackageManagerAdapter();
             case PackageManagerType_1.PackageManagerType.npm:
                 return new NpmPackageManagerAdapter_1.NpmPackageManagerAdapter();
             default:
-                throw new Error("Unsupported package manager: ".concat(packageManager));
+                throw new Error(`Unsupported package manager: ${packageManager}`);
         }
-    };
-    return PackageManagerService;
-}());
+    }
+}
 exports.PackageManagerService = PackageManagerService;

package/dist/services/PeerDependenciesService.js

@@ -1,116 +1,58 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PeerDependenciesService = void 0;
-var fs_1 = require("fs");
-var path_1 = require("path");
-var PackageJson_1 = require("./PackageJson");
-var PluginService_1 = require("./PluginService");
-var PeerDependenciesService = /** @class */ (function () {
-    function PeerDependenciesService() {
-    }
-    PeerDependenciesService.executeResolution = function (absoluteProjectDir) {
-        return __awaiter(this, void 0, void 0, function () {
-            var installedPlugins, missingPeers, packagesToInspect, _i, packagesToInspect_1, packageToInspect, peers, _a, peers_1, peer, isResolvable, sourcePath;
-            return __generator(this, function (_b) {
-                console.info("Resolving peer dependencies...");
-                installedPlugins = PluginService_1.PluginService.getInstalledPlugins(absoluteProjectDir);
-                missingPeers = [];
-                packagesToInspect = PeerDependenciesService.getPackagesToInspect(absoluteProjectDir, installedPlugins);
-                for (_i = 0, packagesToInspect_1 = packagesToInspect; _i < packagesToInspect_1.length; _i++) {
-                    packageToInspect = packagesToInspect_1[_i];
-                    peers = PeerDependenciesService.getPackagePeerDependencies(packageToInspect.path);
-                    for (_a = 0, peers_1 = peers; _a < peers_1.length; _a++) {
-                        peer = peers_1[_a];
-                        isResolvable = PeerDependenciesService.canResolveFromConsumerRoot(absoluteProjectDir, peer.name);
-                        if (!isResolvable) {
-                            sourcePath = PeerDependenciesService.resolvePeerSourcePath(absoluteProjectDir, packageToInspect.path, peer.name);
-                            if (peer.optional && !(0, fs_1.existsSync)(sourcePath)) {
-                                continue;
-                            }
-                            missingPeers.push(__assign(__assign({}, peer), { requiredBy: packageToInspect.name, sourcePath: sourcePath }));
-                        }
+const fs_1 = require("fs");
+const path_1 = require("path");
+const PackageJson_1 = require("./PackageJson");
+const PluginService_1 = require("./PluginService");
+class PeerDependenciesService {
+    static async executeResolution(absoluteProjectDir) {
+        console.info(`Resolving peer dependencies...`);
+        const installedPlugins = PluginService_1.PluginService.getInstalledPlugins(absoluteProjectDir);
+        const missingPeers = [];
+        const packagesToInspect = PeerDependenciesService.getPackagesToInspect(absoluteProjectDir, installedPlugins);
+        for (const packageToInspect of packagesToInspect) {
+            const peers = PeerDependenciesService.getPackagePeerDependencies(packageToInspect.path);
+            for (const peer of peers) {
+                const isResolvable = PeerDependenciesService.canResolveFromConsumerRoot(absoluteProjectDir, peer.name);
+                if (!isResolvable) {
+                    const sourcePath = PeerDependenciesService.resolvePeerSourcePath(absoluteProjectDir, packageToInspect.path, peer.name);
+                    if (peer.optional && !(0, fs_1.existsSync)(sourcePath)) {
+                        continue;
                     }
+                    missingPeers.push({
+                        ...peer,
+                        requiredBy: packageToInspect.name,
+                        sourcePath,
+                    });
                 }
-                if (missingPeers.length > 0) {
-                    PeerDependenciesService.symlinkMissingPeers(absoluteProjectDir, missingPeers);
-                }
-                console.info("Resolving peer dependencies done!");
-                return [2 /*return*/];
-            });
-        });
-    };
-    PeerDependenciesService.getPackagePeerDependencies = function (packageDirPath) {
-        var packageJson = PackageJson_1.PackageJson.fromDirPath(packageDirPath);
-        var content = packageJson.getContent();
-        var peerDependencies = content.peerDependencies || {};
-        var peerDependenciesMeta = content.peerDependenciesMeta || {};
-        return Object.keys(peerDependencies).map(function (name) {
-            var _a;
-            return ({
-                name: name,
-                optional: ((_a = peerDependenciesMeta[name]) === null || _a === void 0 ? void 0 : _a.optional) || false,
-            });
-        });
-    };
-    PeerDependenciesService.getPackagesToInspect = function (absoluteProjectDir, installedPlugins) {
-        var packages = new Map();
-        for (var _i = 0, installedPlugins_1 = installedPlugins; _i < installedPlugins_1.length; _i++) {
-            var plugin = installedPlugins_1[_i];
+            }
+        }
+        if (missingPeers.length > 0) {
+            PeerDependenciesService.symlinkMissingPeers(absoluteProjectDir, missingPeers);
+        }
+        console.info(`Resolving peer dependencies done!`);
+    }
+    static getPackagePeerDependencies(packageDirPath) {
+        const packageJson = PackageJson_1.PackageJson.fromDirPath(packageDirPath);
+        const content = packageJson.getContent();
+        const peerDependencies = content.peerDependencies || {};
+        const peerDependenciesMeta = content.peerDependenciesMeta || {};
+        return Object.keys(peerDependencies).map((name) => ({
+            name,
+            optional: peerDependenciesMeta[name]?.optional || false,
+        }));
+    }
+    static getPackagesToInspect(absoluteProjectDir, installedPlugins) {
+        const packages = new Map();
+        for (const plugin of installedPlugins) {
             packages.set(plugin.fullname, {
                 name: plugin.fullname,
                 path: plugin.path,
             });
-            var pluginDependencies = PackageJson_1.PackageJson.fromDirPath(plugin.path).getDependenciesPackageNames();
-            for (var _a = 0, pluginDependencies_1 = pluginDependencies; _a < pluginDependencies_1.length; _a++) {
-                var dependencyName = pluginDependencies_1[_a];
-                var dependencyPath = PeerDependenciesService.resolveDependencyPath(absoluteProjectDir, plugin.path, dependencyName);
+            const pluginDependencies = PackageJson_1.PackageJson.fromDirPath(plugin.path).getDependenciesPackageNames();
+            for (const dependencyName of pluginDependencies) {
+                const dependencyPath = PeerDependenciesService.resolveDependencyPath(absoluteProjectDir, plugin.path, dependencyName);
                 if (!dependencyPath) {
                     continue;
                 }
@@ -123,112 +65,105 @@ var PeerDependenciesService = /** @class */ (function () {
             }
         }
         return Array.from(packages.values());
-    };
-    PeerDependenciesService.resolveDependencyPath = function (absoluteProjectDir, pluginPath, dependencyName) {
-        var candidatePaths = [
+    }
+    static resolveDependencyPath(absoluteProjectDir, pluginPath, dependencyName) {
+        const candidatePaths = [
             (0, path_1.join)(absoluteProjectDir, PeerDependenciesService.DEPENDENCIES_FOLDER, dependencyName),
             (0, path_1.join)(pluginPath, PeerDependenciesService.DEPENDENCIES_FOLDER, dependencyName),
         ];
-        for (var _i = 0, candidatePaths_1 = candidatePaths; _i < candidatePaths_1.length; _i++) {
-            var candidatePath = candidatePaths_1[_i];
+        for (const candidatePath of candidatePaths) {
             if ((0, fs_1.existsSync)((0, path_1.join)(candidatePath, "package.json"))) {
                 return candidatePath;
             }
         }
         return undefined;
-    };
-    PeerDependenciesService.resolvePeerSourcePath = function (absoluteProjectDir, requiredByPath, peerName) {
-        var projectNodeModulesPath = (0, path_1.join)(absoluteProjectDir, PeerDependenciesService.DEPENDENCIES_FOLDER);
-        var directResolution = PeerDependenciesService.resolvePackagePathFrom(requiredByPath, peerName);
+    }
+    static resolvePeerSourcePath(absoluteProjectDir, requiredByPath, peerName) {
+        const projectNodeModulesPath = (0, path_1.join)(absoluteProjectDir, PeerDependenciesService.DEPENDENCIES_FOLDER);
+        const directResolution = PeerDependenciesService.resolvePackagePathFrom(requiredByPath, peerName);
         if (directResolution) {
             return directResolution;
         }
-        var projectResolution = PeerDependenciesService.resolvePackagePathFrom(projectNodeModulesPath, peerName);
+        const projectResolution = PeerDependenciesService.resolvePackagePathFrom(projectNodeModulesPath, peerName);
         if (projectResolution) {
             return projectResolution;
         }
-        var nestedResolution = PeerDependenciesService.resolveFromNestedNodeModules(projectNodeModulesPath, peerName);
+        const nestedResolution = PeerDependenciesService.resolveFromNestedNodeModules(projectNodeModulesPath, peerName);
         if (nestedResolution) {
             return nestedResolution;
         }
         return (0, path_1.join)(projectNodeModulesPath, peerName);
-    };
-    PeerDependenciesService.resolveFromNestedNodeModules = function (projectNodeModulesPath, peerName) {
-        var packageDirs = PeerDependenciesService.getTopLevelPackageDirs(projectNodeModulesPath);
-        for (var _i = 0, packageDirs_1 = packageDirs; _i < packageDirs_1.length; _i++) {
-            var packageDir = packageDirs_1[_i];
-            var resolvedPath = PeerDependenciesService.resolvePackagePathFrom(packageDir, peerName);
+    }
+    static resolveFromNestedNodeModules(projectNodeModulesPath, peerName) {
+        const packageDirs = PeerDependenciesService.getTopLevelPackageDirs(projectNodeModulesPath);
+        for (const packageDir of packageDirs) {
+            const resolvedPath = PeerDependenciesService.resolvePackagePathFrom(packageDir, peerName);
             if (resolvedPath) {
                 return resolvedPath;
             }
         }
         return undefined;
-    };
-    PeerDependenciesService.getTopLevelPackageDirs = function (nodeModulesPath) {
+    }
+    static getTopLevelPackageDirs(nodeModulesPath) {
         if (!(0, fs_1.existsSync)(nodeModulesPath)) {
             return [];
         }
-        var packageDirs = [];
-        var entries = (0, fs_1.readdirSync)(nodeModulesPath);
-        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
-            var entry = entries_1[_i];
-            var entryPath = (0, path_1.join)(nodeModulesPath, entry);
+        const packageDirs = [];
+        const entries = (0, fs_1.readdirSync)(nodeModulesPath);
+        for (const entry of entries) {
+            const entryPath = (0, path_1.join)(nodeModulesPath, entry);
             if (!entry.startsWith("@")) {
                 packageDirs.push(entryPath);
                 continue;
             }
-            var scopedEntries = (0, fs_1.readdirSync)(entryPath);
-            for (var _a = 0, scopedEntries_1 = scopedEntries; _a < scopedEntries_1.length; _a++) {
-                var scopedEntry = scopedEntries_1[_a];
+            const scopedEntries = (0, fs_1.readdirSync)(entryPath);
+            for (const scopedEntry of scopedEntries) {
                 packageDirs.push((0, path_1.join)(entryPath, scopedEntry));
             }
         }
         return packageDirs;
-    };
-    PeerDependenciesService.resolvePackagePathFrom = function (fromPath, packageName) {
+    }
+    static resolvePackagePathFrom(fromPath, packageName) {
         try {
-            var packageJsonPath = require.resolve((0, path_1.join)(packageName, "package.json"), {
+            const packageJsonPath = require.resolve((0, path_1.join)(packageName, "package.json"), {
                 paths: [fromPath],
             });
             return (0, path_1.dirname)(packageJsonPath);
         }
-        catch (_a) {
+        catch {
             return undefined;
         }
-    };
-    PeerDependenciesService.canResolveFromConsumerRoot = function (absoluteProjectDir, packageName) {
-        var packagePath = (0, path_1.join)(absoluteProjectDir, PeerDependenciesService.DEPENDENCIES_FOLDER, packageName);
+    }
+    static canResolveFromConsumerRoot(absoluteProjectDir, packageName) {
+        const packagePath = (0, path_1.join)(absoluteProjectDir, PeerDependenciesService.DEPENDENCIES_FOLDER, packageName);
         return (0, fs_1.existsSync)(packagePath);
-    };
-    PeerDependenciesService.symlinkMissingPeers = function (absoluteProjectDir, missingPeers) {
-        var projectDependencyPath = (0, path_1.join)(absoluteProjectDir, PeerDependenciesService.DEPENDENCIES_FOLDER);
-        var uniqueMissingPeers = new Map();
-        for (var _i = 0, missingPeers_1 = missingPeers; _i < missingPeers_1.length; _i++) {
-            var peer = missingPeers_1[_i];
+    }
+    static symlinkMissingPeers(absoluteProjectDir, missingPeers) {
+        const projectDependencyPath = (0, path_1.join)(absoluteProjectDir, PeerDependenciesService.DEPENDENCIES_FOLDER);
+        const uniqueMissingPeers = new Map();
+        for (const peer of missingPeers) {
             if (!uniqueMissingPeers.has(peer.name)) {
                 uniqueMissingPeers.set(peer.name, peer);
             }
         }
-        for (var _a = 0, _b = Array.from(uniqueMissingPeers.values()); _a < _b.length; _a++) {
-            var peer = _b[_a];
-            var peerSourcePath = peer.sourcePath;
+        for (const peer of Array.from(uniqueMissingPeers.values())) {
+            const peerSourcePath = peer.sourcePath;
             if (!(0, fs_1.existsSync)(peerSourcePath)) {
-                console.warn("- Peer dependency \"".concat(peer.name, "\" required by \"").concat(peer.requiredBy, "\" not found in plugin node_modules"));
+                console.warn(`- Peer dependency "${peer.name}" required by "${peer.requiredBy}" not found in plugin node_modules`);
                 continue;
             }
-            var peerTargetPath = (0, path_1.join)(projectDependencyPath, peer.name);
-            console.info("- Symlinking peer dependency \"".concat(peer.name, "\" required by \"").concat(peer.requiredBy, "\""));
+            const peerTargetPath = (0, path_1.join)(projectDependencyPath, peer.name);
+            console.info(`- Symlinking peer dependency "${peer.name}" required by "${peer.requiredBy}"`);
             PeerDependenciesService.symlinkPeer(peerSourcePath, peerTargetPath);
         }
-    };
-    PeerDependenciesService.symlinkPeer = function (sourcePath, targetPath) {
-        var targetParentFolder = (0, path_1.join)(targetPath, "..");
+    }
+    static symlinkPeer(sourcePath, targetPath) {
+        const targetParentFolder = (0, path_1.join)(targetPath, "..");
         if (!(0, fs_1.existsSync)(targetParentFolder)) {
             (0, fs_1.mkdirSync)(targetParentFolder, { recursive: true });
         }
         (0, fs_1.symlinkSync)(sourcePath, targetPath);
-    };
-    PeerDependenciesService.DEPENDENCIES_FOLDER = "node_modules";
-    return PeerDependenciesService;
-}());
+    }
+}
 exports.PeerDependenciesService = PeerDependenciesService;
+PeerDependenciesService.DEPENDENCIES_FOLDER = "node_modules";

package/dist/services/PluginService.js

@@ -1,58 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginService = void 0;
-var fs_1 = require("fs");
-var path_1 = require("path");
-var constants_1 = require("../constants");
-var CorePackageService_1 = require("./CorePackageService");
-var PackageJson_1 = require("./PackageJson");
-var PluginService = /** @class */ (function () {
-    function PluginService() {
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const CorePackageService_1 = require("./CorePackageService");
+const PackageJson_1 = require("./PackageJson");
+class PluginService {
+    static packageNameIsPlugin(packageName) {
+        return packageName.match(new RegExp(`^${constants_1.PACKAGE_BASE_NAME}/.*$`));
     }
-    PluginService.packageNameIsPlugin = function (packageName) {
-        return packageName.match(new RegExp("^".concat(constants_1.PACKAGE_BASE_NAME, "/.*$")));
-    };
-    PluginService.getInstalledPlugins = function (absoluteProjectDir) {
-        var packageJson = PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir);
-        var allDependenciesPackageNames = packageJson.getAllDependenciesPackageNames();
+    static getInstalledPlugins(absoluteProjectDir) {
+        const packageJson = PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir);
+        const allDependenciesPackageNames = packageJson.getAllDependenciesPackageNames();
         if (!allDependenciesPackageNames.length) {
             return [];
         }
-        var pluginsFullname = allDependenciesPackageNames.filter(function (packageName) {
-            return PluginService.packageNameIsPlugin(packageName);
-        });
-        var sortPlugins = function (pluginA, pluginB) { return pluginA.localeCompare(pluginB); };
+        const pluginsFullname = allDependenciesPackageNames.filter((packageName) => PluginService.packageNameIsPlugin(packageName));
+        const sortPlugins = (pluginA, pluginB) => pluginA.localeCompare(pluginB);
         pluginsFullname.sort(sortPlugins);
-        var plugins = new Map();
-        for (var _i = 0, pluginsFullname_1 = pluginsFullname; _i < pluginsFullname_1.length; _i++) {
-            var pluginFullname = pluginsFullname_1[_i];
-            var plugin = PluginService.getPluginFromFullname(pluginFullname);
+        const plugins = new Map();
+        for (const pluginFullname of pluginsFullname) {
+            const plugin = PluginService.getPluginFromFullname(pluginFullname);
             plugins.set(pluginFullname, plugin);
-            var pluginParents = PluginService.getInstalledPlugins(plugin.path);
-            for (var _a = 0, pluginParents_1 = pluginParents; _a < pluginParents_1.length; _a++) {
-                var pluginParent = pluginParents_1[_a];
+            const pluginParents = PluginService.getInstalledPlugins(plugin.path);
+            for (const pluginParent of pluginParents) {
                 plugins.set(pluginParent.fullname, pluginParent);
             }
         }
         return Array.from(plugins.values());
-    };
-    PluginService.getPluginShortname = function (fullname) {
-        var shortname = fullname.replace("".concat(constants_1.PACKAGE_BASE_NAME, "/"), "");
+    }
+    static getPluginShortname(fullname) {
+        const shortname = fullname.replace(`${constants_1.PACKAGE_BASE_NAME}/`, "");
         return shortname;
-    };
-    PluginService.getPluginFromFullname = function (fullname) {
-        var corePackageRootPath = CorePackageService_1.CorePackageService.getPackageRootPath();
-        var shortname = PluginService.getPluginShortname(fullname);
-        var path = (0, path_1.resolve)(corePackageRootPath, "../", shortname);
+    }
+    static getPluginFromFullname(fullname) {
+        const corePackageRootPath = CorePackageService_1.CorePackageService.getPackageRootPath();
+        const shortname = PluginService.getPluginShortname(fullname);
+        const path = (0, path_1.resolve)(corePackageRootPath, "../", shortname);
         if (!(0, fs_1.existsSync)(path)) {
-            throw new Error("Plugin \"".concat(fullname, "\" is required but cannot be found in ").concat(path, "."));
+            throw new Error(`Plugin "${fullname}" is required but cannot be found in ${path}.`);
         }
         return {
-            fullname: fullname,
-            shortname: shortname,
-            path: path,
+            fullname,
+            shortname,
+            path,
         };
-    };
-    return PluginService;
-}());
+    }
+}
 exports.PluginService = PluginService;