@ts-dev-tools/core 1.10.0 → 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/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/YarnPackageManagerAdapter.d.ts

@@ -4,10 +4,11 @@ export declare class YarnPackageManagerAdapter extends AbstractPackageManagerAda
     isMonorepo(dirPath: string): Promise<boolean>;
     isPackageInstalled(packageName: string, dirPath: string): Promise<boolean>;
     getNodeModulesPath(dirPath: string): Promise<string>;
-    private yarnWorkspacesOutputHasEntries;
+    private analyzeYarnWorkspacesOutput;
     private parseMaybeJsonString;
+    private extractJsonBlock;
     private hasWorkspaceMap;
-    private parseJsonObjectFromOutput;
     private isWorkspaceListEntry;
+    private isWorkspaceInfoMap;
     private yarnListOutputHasPackage;
 }

package/dist/services/package-manager/YarnPackageManagerAdapter.js

@@ -101,7 +101,7 @@ var YarnPackageManagerAdapter = /** @class */ (function (_super) {
     };
     YarnPackageManagerAdapter.prototype.isMonorepo = function (dirPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var major, primary, fallback, yarnCommands, _i, yarnCommands_1, args, output, _a;
+            var major, primary, fallback, yarnCommands, lastOutput, hasRecognizedOutput, hasSuccessfulCommand, _i, yarnCommands_1, args, output, analysis, _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0: return [4 /*yield*/, this.getVersion(PackageManagerType_1.PackageManagerType.yarn, dirPath)];
@@ -113,6 +113,8 @@ var YarnPackageManagerAdapter = /** @class */ (function (_super) {
                             ["yarn", "workspaces", primary, "--json"],
                             ["yarn", "workspaces", fallback, "--json"],
                         ];
+                        hasRecognizedOutput = false;
+                        hasSuccessfulCommand = false;
                         _i = 0, yarnCommands_1 = yarnCommands;
                         _b.label = 2;
                     case 2:
@@ -124,9 +126,15 @@ var YarnPackageManagerAdapter = /** @class */ (function (_super) {
                         return [4 /*yield*/, this.execCommand(args, dirPath, true)];
                     case 4:
                         output = _b.sent();
-                        if (this.yarnWorkspacesOutputHasEntries(output)) {
+                        hasSuccessfulCommand = true;
+                        lastOutput = output;
+                        analysis = this.analyzeYarnWorkspacesOutput(output);
+                        if (analysis.hasEntries) {
                             return [2 /*return*/, true];
                         }
+                        if (analysis.hasRecognizedData) {
+                            hasRecognizedOutput = true;
+                        }
                         return [3 /*break*/, 6];
                     case 5:
                         _a = _b.sent();
@@ -134,7 +142,11 @@ var YarnPackageManagerAdapter = /** @class */ (function (_super) {
                     case 6:
                         _i++;
                         return [3 /*break*/, 2];
-                    case 7: return [2 /*return*/, false];
+                    case 7:
+                        if (hasSuccessfulCommand && !hasRecognizedOutput) {
+                            throw new Error("Unexpected output from \"yarn workspaces\": ".concat(lastOutput !== null && lastOutput !== void 0 ? lastOutput : "<empty>"));
+                        }
+                        return [2 /*return*/, false];
                 }
             });
         });
@@ -177,20 +189,38 @@ var YarnPackageManagerAdapter = /** @class */ (function (_super) {
             });
         });
     };
-    YarnPackageManagerAdapter.prototype.yarnWorkspacesOutputHasEntries = function (output) {
+    YarnPackageManagerAdapter.prototype.analyzeYarnWorkspacesOutput = function (output) {
         var _a;
         var entries = this.parseJsonLines(output);
+        if (entries.length === 0) {
+            var jsonBlock = this.extractJsonBlock(output);
+            if (jsonBlock && typeof jsonBlock === "object") {
+                entries = [jsonBlock];
+            }
+        }
+        if (entries.length === 0) {
+            return { hasEntries: false, hasRecognizedData: false };
+        }
         var workspaceListCount = 0;
+        var hasRecognizedData = false;
         for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
             var entry = entries_1[_i];
             if (!entry || typeof entry !== "object") {
                 continue;
             }
+            var type = entry.type;
+            if (type === "error" || type === "warning") {
+                continue;
+            }
             var data = (_a = entry.data) !== null && _a !== void 0 ? _a : entry;
             var parsedData = this.parseMaybeJsonString(data);
             if (parsedData && typeof parsedData === "object") {
+                hasRecognizedData = true;
                 if (this.hasWorkspaceMap(parsedData)) {
-                    return true;
+                    return { hasEntries: true, hasRecognizedData: hasRecognizedData };
+                }
+                if (this.isWorkspaceInfoMap(parsedData)) {
+                    return { hasEntries: true, hasRecognizedData: hasRecognizedData };
                 }
                 if (this.isWorkspaceListEntry(parsedData)) {
                     workspaceListCount += 1;
@@ -198,13 +228,9 @@ var YarnPackageManagerAdapter = /** @class */ (function (_super) {
             }
         }
         if (workspaceListCount > 0) {
-            return true;
-        }
-        var parsedOutput = this.parseJsonObjectFromOutput(output);
-        if (parsedOutput && typeof parsedOutput === "object") {
-            return Object.keys(parsedOutput).length > 0;
+            return { hasEntries: true, hasRecognizedData: hasRecognizedData };
         }
-        return false;
+        return { hasEntries: false, hasRecognizedData: hasRecognizedData };
     };
     YarnPackageManagerAdapter.prototype.parseMaybeJsonString = function (value) {
         if (typeof value !== "string") {
@@ -217,27 +243,30 @@ var YarnPackageManagerAdapter = /** @class */ (function (_super) {
             return undefined;
         }
     };
-    YarnPackageManagerAdapter.prototype.hasWorkspaceMap = function (value) {
-        if (!value || typeof value !== "object") {
-            return false;
-        }
-        var workspaces = value.workspaces;
-        return !!workspaces && Object.keys(workspaces).length > 0;
-    };
-    YarnPackageManagerAdapter.prototype.parseJsonObjectFromOutput = function (output) {
+    YarnPackageManagerAdapter.prototype.extractJsonBlock = function (output) {
         var start = output.indexOf("{");
         var end = output.lastIndexOf("}");
-        if (start < 0 || end <= start) {
+        if (start === -1 || end === -1 || end <= start) {
+            return undefined;
+        }
+        var candidate = output.slice(start, end + 1).trim();
+        if (candidate.length === 0) {
             return undefined;
         }
-        var slice = output.slice(start, end + 1).trim();
         try {
-            return JSON.parse(slice);
+            return JSON.parse(candidate);
         }
         catch (_a) {
             return undefined;
         }
     };
+    YarnPackageManagerAdapter.prototype.hasWorkspaceMap = function (value) {
+        if (!value || typeof value !== "object") {
+            return false;
+        }
+        var workspaces = value.workspaces;
+        return !!workspaces && Object.keys(workspaces).length > 0;
+    };
     YarnPackageManagerAdapter.prototype.isWorkspaceListEntry = function (value) {
         if (!value || typeof value !== "object") {
             return false;
@@ -245,6 +274,22 @@ var YarnPackageManagerAdapter = /** @class */ (function (_super) {
         var entry = value;
         return typeof entry.name === "string" && typeof entry.location === "string" && entry.location !== ".";
     };
+    YarnPackageManagerAdapter.prototype.isWorkspaceInfoMap = function (value) {
+        if (!value || typeof value !== "object") {
+            return false;
+        }
+        var entries = Object.values(value);
+        if (entries.length === 0) {
+            return false;
+        }
+        return entries.some(function (entry) {
+            if (!entry || typeof entry !== "object") {
+                return false;
+            }
+            var location = entry.location;
+            return typeof location === "string" && location.length > 0 && location !== ".";
+        });
+    };
     YarnPackageManagerAdapter.prototype.yarnListOutputHasPackage = function (output, packageName) {
         var _a;
         var entries = this.parseJsonLines(output);
@@ -256,6 +301,13 @@ var YarnPackageManagerAdapter = /** @class */ (function (_super) {
             var data = entry.data;
             var trees = (_a = data === null || data === void 0 ? void 0 : data.trees) !== null && _a !== void 0 ? _a : entry.trees;
             if (!trees) {
+                var children = entry.children;
+                if (children) {
+                    var childKeys = Object.keys(children);
+                    if (childKeys.some(function (key) { return key.startsWith(packageName + "@"); })) {
+                        return true;
+                    }
+                }
                 continue;
             }
             if (trees.some(function (tree) { return tree.name.startsWith(packageName + "@"); })) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-dev-tools/core",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "TS dev tools Core",
   "keywords": [
     "linter",
@@ -93,5 +93,5 @@
       "github-actions"
     ]
   },
-  "gitHead": "e45076a10f72cd59f296dc30abdbe692aa8684b1"
+  "gitHead": "9181a105b83523716cb8579991fd77f21a0e9ef6"
 }