fix(core): yarn 4 support

Signed-off-by: Emilien Escalle <emilien.escalle@escemi.com>

Author: neilime

.yarnrc

@@ -102,6 +102,37 @@ pnpm ts-dev-tools install
 
 Contributions, issues and feature requests are welcome!<br />Feel free to check [issues page](https://github.com/escemi-tech/ts-dev-tools/issues). You can also take a look at the [contributing guide](CONTRIBUTING) and [Contributor Code of Conduct](CODE-OF-CONDUCT.md).
 
+### Developer setup
+
+```sh
+npm install
+```
+
+### Checks
+
+```sh
+npm run lint
+npm run test
+npm run build
+```
+
+Or run everything in one command:
+
+```sh
+npm run ci
+```
+
+### Clean cache
+
+For some reason, if you need to clean cache, you can run the following commands:
+
+```sh
+# Test cache
+rm -rf node_modules/.cache/ts-dev-tools
+# NX cache
+npx nx reset
+```
+
 ## Show your support
 
 Give a ⭐️ if this project helped you!

README.md

@@ -13,7 +13,7 @@ describe("bin", () => {
   it("should display version", async () => {
     const result = await execBin("--version");
     expect(result.stderr).toBeFalsy();
-    expect(result.stdout).toMatch(/[0-9]{1}\.[0-9]{1}\.[0-9]{1}/);
+    expect(result.stdout).toMatch(/[0-9]+\.[0-9]+\.[0-9]+/);
     expect(result.code).toBe(0);
   }, 10000);
 

packages/core/src/bin.spec.ts

@@ -30,7 +30,8 @@ export class SymlinkDependenciesService {
 
     const pluginDependenciesPath = await SymlinkDependenciesService.getPluginDependenciesPath(
       absoluteProjectDir,
-      plugin
+      plugin,
+      pluginDependencies
     );
 
     if (projectDependencyPath === pluginDependenciesPath) {
@@ -67,15 +68,22 @@ export class SymlinkDependenciesService {
 
   private static async getPluginDependenciesPath(
     absoluteProjectDir: string,
-    plugin: Plugin
+    plugin: Plugin,
+    pluginDependencies: string[]
   ): Promise<string> {
     const pluginDependenciesPath = join(
       plugin.path,
       SymlinkDependenciesService.DEPENDENCIES_FOLDER
     );
 
     if (existsSync(pluginDependenciesPath)) {
-      return pluginDependenciesPath;
+      const hasAnyPluginDependency = pluginDependencies.some((pluginDependency) =>
+        existsSync(join(pluginDependenciesPath, pluginDependency))
+      );
+
+      if (hasAnyPluginDependency) {
+        return pluginDependenciesPath;
+      }
     }
 
     return await PackageManagerService.getNodeModulesPath(absoluteProjectDir);

packages/core/src/services/SymlinkDependenciesService.ts

@@ -39,18 +39,35 @@ export class YarnPackageManagerAdapter extends AbstractPackageManagerAdapter {
             ["yarn", "workspaces", primary, "--json"],
             ["yarn", "workspaces", fallback, "--json"],
         ];
+        let lastOutput: string | undefined;
+        let hasRecognizedOutput = false;
+        let hasSuccessfulCommand = false;
 
         for (const args of yarnCommands) {
             try {
                 const output = await this.execCommand(args, dirPath, true);
-                if (this.yarnWorkspacesOutputHasEntries(output)) {
+                hasSuccessfulCommand = true;
+                lastOutput = output;
+
+                const analysis = this.analyzeYarnWorkspacesOutput(output);
+                if (analysis.hasEntries) {
                     return true;
                 }
+
+                if (analysis.hasRecognizedData) {
+                    hasRecognizedOutput = true;
+                }
             } catch {
                 // Try next command
             }
         }
 
+        if (hasSuccessfulCommand && !hasRecognizedOutput) {
+            throw new Error(
+                `Unexpected output from "yarn workspaces": ${lastOutput ?? "<empty>"}`
+            );
+        }
+
         return false;
     }
 
@@ -74,28 +91,53 @@ export class YarnPackageManagerAdapter extends AbstractPackageManagerAdapter {
         } catch {
             return false;
         }
+
     }
 
     async getNodeModulesPath(dirPath: string): Promise<string> {
         return join(dirPath, "node_modules");
     }
 
-    private yarnWorkspacesOutputHasEntries(output: string): boolean {
-        const entries = this.parseJsonLines(output);
+    private analyzeYarnWorkspacesOutput(
+        output: string
+    ): { hasEntries: boolean; hasRecognizedData: boolean } {
+        let entries = this.parseJsonLines(output);
+
+        if (entries.length === 0) {
+            const jsonBlock = this.extractJsonBlock(output);
+            if (jsonBlock && typeof jsonBlock === "object") {
+                entries = [jsonBlock];
+            }
+        }
+
+        if (entries.length === 0) {
+            return { hasEntries: false, hasRecognizedData: false };
+        }
 
         let workspaceListCount = 0;
+        let hasRecognizedData = false;
 
         for (const entry of entries) {
             if (!entry || typeof entry !== "object") {
                 continue;
             }
 
+            const type = (entry as { type?: string }).type;
+            if (type === "error" || type === "warning") {
+                continue;
+            }
+
             const data = (entry as { data?: unknown }).data ?? entry;
 
             const parsedData = this.parseMaybeJsonString(data);
             if (parsedData && typeof parsedData === "object") {
+                hasRecognizedData = true;
                 if (this.hasWorkspaceMap(parsedData)) {
-                    return true;
+                    return { hasEntries: true, hasRecognizedData };
+                }
+
+                if (this.isWorkspaceInfoMap(parsedData)) {
+                    return { hasEntries: true, hasRecognizedData };
                 }
 
                 if (this.isWorkspaceListEntry(parsedData)) {
@@ -105,15 +147,9 @@ export class YarnPackageManagerAdapter extends AbstractPackageManagerAdapter {
         }
 
         if (workspaceListCount > 0) {
-            return true;
+            return { hasEntries: true, hasRecognizedData };
         }
-
-        const parsedOutput = this.parseJsonObjectFromOutput(output);
-        if (parsedOutput && typeof parsedOutput === "object") {
-            return Object.keys(parsedOutput as Record<string, unknown>).length > 0;
-        }
-
-        return false;
+        return { hasEntries: false, hasRecognizedData };
     }
 
     private parseMaybeJsonString(value: unknown): unknown {
@@ -128,31 +164,35 @@ export class YarnPackageManagerAdapter extends AbstractPackageManagerAdapter {
         }
     }
 
-    private hasWorkspaceMap(value: unknown): boolean {
-        if (!value || typeof value !== "object") {
-            return false;
-        }
-
-        const workspaces = (value as { workspaces?: Record<string, unknown> }).workspaces;
-        return !!workspaces && Object.keys(workspaces).length > 0;
-    }
-
-    private parseJsonObjectFromOutput(output: string): unknown {
+    private extractJsonBlock(output: string): unknown {
         const start = output.indexOf("{");
         const end = output.lastIndexOf("}");
 
-        if (start < 0 || end <= start) {
+        if (start === -1 || end === -1 || end <= start) {
+            return undefined;
+        }
+
+        const candidate = output.slice(start, end + 1).trim();
+        if (candidate.length === 0) {
             return undefined;
         }
 
-        const slice = output.slice(start, end + 1).trim();
         try {
-            return JSON.parse(slice) as unknown;
+            return JSON.parse(candidate) as unknown;
         } catch {
             return undefined;
         }
     }
 
+    private hasWorkspaceMap(value: unknown): boolean {
+        if (!value || typeof value !== "object") {
+            return false;
+        }
+
+        const workspaces = (value as { workspaces?: Record<string, unknown> }).workspaces;
+        return !!workspaces && Object.keys(workspaces).length > 0;
+    }
+
     private isWorkspaceListEntry(value: unknown): boolean {
         if (!value || typeof value !== "object") {
             return false;
@@ -162,6 +202,26 @@ export class YarnPackageManagerAdapter extends AbstractPackageManagerAdapter {
         return typeof entry.name === "string" && typeof entry.location === "string" && entry.location !== ".";
     }
 
+    private isWorkspaceInfoMap(value: unknown): boolean {
+        if (!value || typeof value !== "object") {
+            return false;
+        }
+
+        const entries = Object.values(value as Record<string, unknown>);
+        if (entries.length === 0) {
+            return false;
+        }
+
+        return entries.some((entry) => {
+            if (!entry || typeof entry !== "object") {
+                return false;
+            }
+
+            const location = (entry as { location?: unknown }).location;
+            return typeof location === "string" && location.length > 0 && location !== ".";
+        });
+    }
+
     private yarnListOutputHasPackage(output: string, packageName: string): boolean {
         const entries = this.parseJsonLines(output);
 
@@ -174,6 +234,13 @@ export class YarnPackageManagerAdapter extends AbstractPackageManagerAdapter {
             const trees = data?.trees ?? (entry as { trees?: Array<{ name: string }> }).trees;
 
             if (!trees) {
+                const children = (entry as { children?: Record<string, unknown> }).children;
+                if (children) {
+                    const childKeys = Object.keys(children);
+                    if (childKeys.some((key) => key.startsWith(packageName + "@"))) {
+                        return true;
+                    }
+                }
                 continue;
             }