@ts-dev-tools/core 1.9.14 → 1.11.0

package/dist/install/command.js

@@ -43,6 +43,7 @@ var constants_1 = require("../constants");
 var DuplicateDependenciesService_1 = require("../services/DuplicateDependenciesService");
 var MigrationsService_1 = require("../services/MigrationsService");
 var PackageJson_1 = require("../services/PackageJson");
+var PeerDependenciesService_1 = require("../services/PeerDependenciesService");
 var SymlinkDependenciesService_1 = require("../services/SymlinkDependenciesService");
 function install(_a) {
     return __awaiter(this, arguments, void 0, function (_b) {
@@ -70,6 +71,9 @@ function install(_a) {
                     _d.sent();
                     return [4 /*yield*/, SymlinkDependenciesService_1.SymlinkDependenciesService.executeSymlinking(absoluteProjectDir)];
                 case 2:
+                    _d.sent();
+                    return [4 /*yield*/, PeerDependenciesService_1.PeerDependenciesService.executeResolution(absoluteProjectDir)];
+                case 3:
                     _d.sent();
                     DuplicateDependenciesService_1.DuplicateDependenciesService.executeDeduplication(absoluteProjectDir);
                     console.info("Installation done!");

package/dist/services/PackageManagerService.d.ts

@@ -1,12 +1,10 @@
-export declare enum PackageManagerType {
-    yarn = "yarn",
-    npm = "npm"
-}
+import { PackageManagerType } from "./package-manager/PackageManagerType";
+export { PackageManagerType } from "./package-manager/PackageManagerType";
 export declare class PackageManagerService {
     static detectPackageManager(dirPath: string): PackageManagerType;
     static addDevPackage(packageName: string, dirPath: string): Promise<void>;
     static isMonorepo(dirPath: string): Promise<boolean>;
     static isPackageInstalled(packageName: string, dirPath: string): Promise<boolean>;
     static getNodeModulesPath(dirPath: string): Promise<string>;
-    private static execCommand;
+    private static getAdapter;
 }

package/dist/services/PackageManagerService.js

@@ -37,246 +37,61 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackageManagerService = exports.PackageManagerType = void 0;
-var child_process_1 = require("child_process");
 var fs_1 = require("fs");
 var path_1 = require("path");
-var PackageManagerType;
-(function (PackageManagerType) {
-    PackageManagerType["yarn"] = "yarn";
-    PackageManagerType["npm"] = "npm";
-})(PackageManagerType || (exports.PackageManagerType = PackageManagerType = {}));
+var NpmPackageManagerAdapter_1 = require("./package-manager/NpmPackageManagerAdapter");
+var PackageManagerType_1 = require("./package-manager/PackageManagerType");
+var 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) {
         if ((0, fs_1.existsSync)((0, path_1.join)(dirPath, "yarn.lock"))) {
-            return PackageManagerType.yarn;
+            return PackageManagerType_1.PackageManagerType.yarn;
         }
-        return PackageManagerType.npm;
+        return PackageManagerType_1.PackageManagerType.npm;
     };
     PackageManagerService.addDevPackage = function (packageName, dirPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var packageManager, isMonorepo, args;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        packageManager = PackageManagerService.detectPackageManager(dirPath);
-                        return [4 /*yield*/, PackageManagerService.isMonorepo(dirPath)];
-                    case 1:
-                        isMonorepo = _a.sent();
-                        args = [packageManager];
-                        switch (packageManager) {
-                            case PackageManagerType.yarn:
-                                args.push("add", "--dev");
-                                if (isMonorepo) {
-                                    args.push("--ignore-workspace-root-check");
-                                }
-                                break;
-                            case PackageManagerType.npm:
-                                args.push("install", "--save-dev");
-                                if (isMonorepo) {
-                                    args.push("--no-workspaces");
-                                }
-                                break;
-                        }
-                        args.push(packageName);
-                        return [4 /*yield*/, PackageManagerService.execCommand(args, dirPath, true)];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
+                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).addDevPackage(packageName, dirPath)];
             });
         });
     };
     PackageManagerService.isMonorepo = function (dirPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var packageManager, args, output;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        packageManager = PackageManagerService.detectPackageManager(dirPath);
-                        args = [packageManager];
-                        switch (packageManager) {
-                            case PackageManagerType.yarn:
-                                args.push("workspaces", "info");
-                                break;
-                            case PackageManagerType.npm:
-                                args.push("--workspaces", "list");
-                                break;
-                        }
-                        args.push("> /dev/null 2>&1 && echo true || echo false;");
-                        return [4 /*yield*/, PackageManagerService.execCommand(args, dirPath, true)];
-                    case 1:
-                        output = _a.sent();
-                        return [2 /*return*/, output.trim() === "true"];
-                }
+                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).isMonorepo(dirPath)];
             });
         });
     };
     PackageManagerService.isPackageInstalled = function (packageName, dirPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var packageManager, args, output, error_1, installedPackages;
-            var _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        packageManager = PackageManagerService.detectPackageManager(dirPath);
-                        args = [packageManager, "list", "--depth=1", "--json"];
-                        switch (packageManager) {
-                            case PackageManagerType.yarn:
-                                args.push("--pattern=".concat(packageName));
-                                break;
-                            case PackageManagerType.npm:
-                                args.push("--no-progress", "--non-interactive", packageName);
-                                break;
-                        }
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, PackageManagerService.execCommand(args, dirPath, true)];
-                    case 2:
-                        output = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _c.sent();
-                        // npm returns non-zero exit code when package is not found, but still outputs valid JSON
-                        if (typeof error_1 === "string") {
-                            try {
-                                // Try to parse as JSON - if successful, use it as output
-                                JSON.parse(error_1.trim());
-                                output = error_1;
-                            }
-                            catch (_d) {
-                                // If it's not valid JSON, the package is not installed
-                                return [2 /*return*/, false];
-                            }
-                        }
-                        else {
-                            return [2 /*return*/, false];
-                        }
-                        return [3 /*break*/, 4];
-                    case 4:
-                        installedPackages = JSON.parse(output);
-                        switch (packageManager) {
-                            case PackageManagerType.yarn:
-                                return [2 /*return*/, (_b = (_a = installedPackages === null || installedPackages === void 0 ? void 0 : installedPackages.data) === null || _a === void 0 ? void 0 : _a.trees) === null || _b === void 0 ? void 0 : _b.some(function (tree) {
-                                        return tree.name.startsWith(packageName + "@");
-                                    })];
-                            case PackageManagerType.npm:
-                                return [2 /*return*/, installedPackages.dependencies
-                                        ? Object.prototype.hasOwnProperty.call(installedPackages.dependencies, packageName)
-                                        : false];
-                        }
-                        return [2 /*return*/];
-                }
+            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 () {
-            var packageManager, nodeModulesPath, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        packageManager = PackageManagerService.detectPackageManager(dirPath);
-                        _a = packageManager;
-                        switch (_a) {
-                            case PackageManagerType.yarn: return [3 /*break*/, 1];
-                            case PackageManagerType.npm: return [3 /*break*/, 2];
-                        }
-                        return [3 /*break*/, 4];
-                    case 1:
-                        nodeModulesPath = (0, path_1.join)(dirPath, "node_modules");
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, PackageManagerService.execCommand([packageManager, "root", "--no-progress", "--non-interactive"], dirPath, true)];
-                    case 3:
-                        nodeModulesPath = (_b.sent()).trim();
-                        return [3 /*break*/, 4];
-                    case 4:
-                        if (nodeModulesPath) {
-                            return [2 /*return*/, nodeModulesPath];
-                        }
-                        throw new Error("Node modules path not found for package manager ".concat(packageManager));
-                }
-            });
-        });
-    };
-    PackageManagerService.execCommand = function (args_1, cwd_1) {
-        return __awaiter(this, arguments, void 0, function (args, cwd, silent) {
-            var cmd, cmdArgs, useShell, SHELL_OPERATORS_1, hasShellSyntax;
-            if (silent === void 0) { silent = false; }
             return __generator(this, function (_a) {
-                // Handle empty args check for both string and array
-                if (Array.isArray(args) && args.length === 0) {
-                    throw new Error("Command args must not be empty");
-                }
-                if (typeof args === "string" && args.trim().length === 0) {
-                    throw new Error("Command args must not be empty");
-                }
-                if (cwd && !(0, fs_1.existsSync)(cwd)) {
-                    throw new Error("Directory \"".concat(cwd, "\" does not exist"));
-                }
-                useShell = false;
-                if (Array.isArray(args)) {
-                    SHELL_OPERATORS_1 = [">", "|", "&&", "||", ";", "<", ">>", "2>", "&", "$("];
-                    hasShellSyntax = args.some(function (arg) {
-                        var trimmedArg = arg.trim();
-                        return SHELL_OPERATORS_1.some(function (op) {
-                            return trimmedArg.startsWith(op) ||
-                                trimmedArg.endsWith(op) ||
-                                trimmedArg.includes(" ".concat(op, " ")) ||
-                                trimmedArg.includes(" ".concat(op)) ||
-                                trimmedArg.includes("".concat(op, " "));
-                        });
-                    });
-                    if (hasShellSyntax) {
-                        // Use shell mode for commands with shell syntax
-                        cmd = args.join(" ").trim();
-                        cmdArgs = [];
-                        useShell = true;
-                    }
-                    else {
-                        // Use array mode for normal commands
-                        cmd = args[0];
-                        cmdArgs = args.slice(1);
-                    }
-                }
-                else {
-                    cmd = args;
-                    cmdArgs = [];
-                    useShell = true;
-                }
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        var child = (0, child_process_1.spawn)(cmd, cmdArgs, {
-                            stdio: silent ? "pipe" : "inherit",
-                            shell: useShell,
-                            windowsVerbatimArguments: true,
-                            cwd: cwd,
-                        });
-                        var output = "";
-                        var error = "";
-                        child.on("exit", function (code) {
-                            if (code) {
-                                // For commands that output to stdout even on error (like npm list),
-                                // reject with the output so caller can handle it
-                                return reject(output.length > 0 ? output : error);
-                            }
-                            resolve(output);
-                        });
-                        if (child.stdout) {
-                            child.stdout.on("data", function (data) {
-                                output += "\n".concat(data);
-                            });
-                        }
-                        if (child.stderr) {
-                            child.stderr.on("data", function (data) {
-                                error += "\n".concat(data);
-                            });
-                        }
-                    })];
+                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).getNodeModulesPath(dirPath)];
             });
         });
     };
+    PackageManagerService.getAdapter = function (dirPath) {
+        var 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));
+        }
+    };
     return PackageManagerService;
 }());
 exports.PackageManagerService = PackageManagerService;

package/dist/services/PeerDependenciesService.d.ts

@@ -0,0 +1,14 @@
+export declare class PeerDependenciesService {
+    static DEPENDENCIES_FOLDER: string;
+    static executeResolution(absoluteProjectDir: string): Promise<void>;
+    private static getPackagePeerDependencies;
+    private static getPackagesToInspect;
+    private static resolveDependencyPath;
+    private static resolvePeerSourcePath;
+    private static resolveFromNestedNodeModules;
+    private static getTopLevelPackageDirs;
+    private static resolvePackagePathFrom;
+    private static canResolveFromConsumerRoot;
+    private static symlinkMissingPeers;
+    private static symlinkPeer;
+}

package/dist/services/PeerDependenciesService.js

@@ -0,0 +1,234 @@
+"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 }));
+                        }
+                    }
+                }
+                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];
+            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);
+                if (!dependencyPath) {
+                    continue;
+                }
+                if (!packages.has(dependencyName)) {
+                    packages.set(dependencyName, {
+                        name: dependencyName,
+                        path: dependencyPath,
+                    });
+                }
+            }
+        }
+        return Array.from(packages.values());
+    };
+    PeerDependenciesService.resolveDependencyPath = function (absoluteProjectDir, pluginPath, dependencyName) {
+        var 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];
+            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);
+        if (directResolution) {
+            return directResolution;
+        }
+        var projectResolution = PeerDependenciesService.resolvePackagePathFrom(projectNodeModulesPath, peerName);
+        if (projectResolution) {
+            return projectResolution;
+        }
+        var 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);
+            if (resolvedPath) {
+                return resolvedPath;
+            }
+        }
+        return undefined;
+    };
+    PeerDependenciesService.getTopLevelPackageDirs = function (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);
+            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];
+                packageDirs.push((0, path_1.join)(entryPath, scopedEntry));
+            }
+        }
+        return packageDirs;
+    };
+    PeerDependenciesService.resolvePackagePathFrom = function (fromPath, packageName) {
+        try {
+            var packageJsonPath = require.resolve((0, path_1.join)(packageName, "package.json"), {
+                paths: [fromPath],
+            });
+            return (0, path_1.dirname)(packageJsonPath);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
+    PeerDependenciesService.canResolveFromConsumerRoot = function (absoluteProjectDir, packageName) {
+        var 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];
+            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;
+            if (!(0, fs_1.existsSync)(peerSourcePath)) {
+                console.warn("- Peer dependency \"".concat(peer.name, "\" required by \"").concat(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, "\""));
+            PeerDependenciesService.symlinkPeer(peerSourcePath, peerTargetPath);
+        }
+    };
+    PeerDependenciesService.symlinkPeer = function (sourcePath, targetPath) {
+        var 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;

package/dist/services/SymlinkDependenciesService.js

@@ -80,7 +80,7 @@ var SymlinkDependenciesService = /** @class */ (function () {
                     case 0:
                         pluginDependencies = SymlinkDependenciesService.getPluginDependencies(plugin);
                         projectDependencyPath = (0, path_1.join)(absoluteProjectDir, SymlinkDependenciesService.DEPENDENCIES_FOLDER);
-                        return [4 /*yield*/, SymlinkDependenciesService.getPluginDependenciesPath(absoluteProjectDir, plugin)];
+                        return [4 /*yield*/, SymlinkDependenciesService.getPluginDependenciesPath(absoluteProjectDir, plugin, pluginDependencies)];
                     case 1:
                         pluginDependenciesPath = _a.sent();
                         if (projectDependencyPath === pluginDependenciesPath) {
@@ -109,15 +109,20 @@ var SymlinkDependenciesService = /** @class */ (function () {
         var pluginPackageJson = PackageJson_1.PackageJson.fromDirPath(plugin.path);
         return pluginPackageJson.getDependenciesPackageNames();
     };
-    SymlinkDependenciesService.getPluginDependenciesPath = function (absoluteProjectDir, plugin) {
+    SymlinkDependenciesService.getPluginDependenciesPath = function (absoluteProjectDir, plugin, pluginDependencies) {
         return __awaiter(this, void 0, void 0, function () {
-            var pluginDependenciesPath;
+            var pluginDependenciesPath, hasAnyPluginDependency;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         pluginDependenciesPath = (0, path_1.join)(plugin.path, SymlinkDependenciesService.DEPENDENCIES_FOLDER);
                         if ((0, fs_1.existsSync)(pluginDependenciesPath)) {
-                            return [2 /*return*/, pluginDependenciesPath];
+                            hasAnyPluginDependency = pluginDependencies.some(function (pluginDependency) {
+                                return (0, fs_1.existsSync)((0, path_1.join)(pluginDependenciesPath, pluginDependency));
+                            });
+                            if (hasAnyPluginDependency) {
+                                return [2 /*return*/, pluginDependenciesPath];
+                            }
                         }
                         return [4 /*yield*/, PackageManagerService_1.PackageManagerService.getNodeModulesPath(absoluteProjectDir)];
                     case 1: return [2 /*return*/, _a.sent()];

package/dist/services/package-manager/AbstractPackageManagerAdapter.d.ts

@@ -0,0 +1,16 @@
+import { PackageManagerType } from "./PackageManagerType";
+import type { PackageManagerAdapter } from "./PackageManagerAdapter";
+export declare abstract class AbstractPackageManagerAdapter implements PackageManagerAdapter {
+    abstract addDevPackage(packageName: string, dirPath: string): Promise<void>;
+    abstract isMonorepo(dirPath: string): Promise<boolean>;
+    abstract isPackageInstalled(packageName: string, dirPath: string): Promise<boolean>;
+    abstract getNodeModulesPath(dirPath: string): Promise<string>;
+    protected getVersion(packageManager: PackageManagerType, dirPath?: string): Promise<{
+        raw: string;
+        major: number;
+        minor: number;
+        patch: number;
+    }>;
+    protected execCommand(args: string | string[], cwd?: string, silent?: boolean): Promise<string>;
+    protected parseJsonLines(output: string): unknown[];
+}