Resolve isolated playground dependencies to installed package targets.

Author: cpojer

packages/void/test/unit/integration-helpers.test.ts

@@ -5,11 +5,14 @@ import {
   mkdirSync,
   mkdtempSync,
   readFileSync,
+  readlinkSync,
+  realpathSync,
   rmSync,
+  symlinkSync,
   writeFileSync,
 } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { isAbsolute, join, relative } from 'node:path';
 import { describe, expect, it } from 'vite-plus/test';
 import {
   createIsolatedPlayground,
@@ -100,3 +103,48 @@ it('clears the shutdown deadline after a real child exits', () => {
   expect(result.status, result.stderr).toBe(0);
   expect(result.stdout.trim()).toBe('[]');
 }, 20_000);
+
+it('resolves installed dependency links absolutely at the isolated fixture depth', () => {
+  const workspace = mkdtempSync(join(tmpdir(), 'void-fixture-dependencies-'));
+  const source = join(workspace, 'playground', 'app');
+  const modules = join(source, 'node_modules');
+  mkdirSync(join(modules, '@fixture'), { recursive: true });
+  writeFileSync(join(source, 'package.json'), JSON.stringify({ name: 'dependency-app' }));
+  writeFileSync(
+    join(source, 'entry.mjs'),
+    'import plain from "plain"; import scoped from "@fixture/scoped"; console.log(JSON.stringify([plain, scoped]));',
+  );
+  for (const name of ['plain', '@fixture/scoped']) {
+    const installed = join(workspace, 'packages', name);
+    mkdirSync(installed, { recursive: true });
+    writeFileSync(
+      join(installed, 'package.json'),
+      JSON.stringify({ name, type: 'module', exports: './index.mjs' }),
+    );
+    writeFileSync(join(installed, 'index.mjs'), `export default ${JSON.stringify(name)};`);
+    const link = join(modules, name);
+    symlinkSync(
+      relative(join(link, '..'), installed),
+      link,
+      process.platform === 'win32' ? 'junction' : 'dir',
+    );
+  }
+  const fixture = createIsolatedPlayground(workspace, 'playground/app');
+  try {
+    for (const name of ['plain', '@fixture/scoped']) {
+      const link = join(fixture.root, 'node_modules', name);
+      expect(isAbsolute(readlinkSync(link))).toBe(true);
+      expect(realpathSync(link)).toBe(realpathSync(join(workspace, 'packages', name)));
+    }
+    const result = spawnSync(process.execPath, ['entry.mjs'], {
+      cwd: fixture.root,
+      encoding: 'utf8',
+      timeout: 10_000,
+    });
+    expect(result.status, result.stderr).toBe(0);
+    expect(JSON.parse(result.stdout)).toEqual(['plain', '@fixture/scoped']);
+  } finally {
+    fixture.cleanup();
+    rmSync(workspace, { recursive: true, force: true });
+  }
+});

packages/void/test/unit/playground-snapshots.test.ts

@@ -17,6 +17,8 @@ it('clones stable source snapshots while resolving dependencies from the actual
   const source = join(root, 'playground/react-pages');
   const snapshot = join(root, 'snapshots/playground/react-pages');
   mkdirSync(join(source, 'node_modules'), { recursive: true });
+  mkdirSync(join(source, 'node_modules', 'fixture-dependency'));
+  writeFileSync(join(source, 'node_modules', 'fixture-dependency', 'index.js'), 'installed source');
   mkdirSync(snapshot, { recursive: true });
   for (const path of [source, snapshot]) {
     writeFileSync(join(path, 'package.json'), JSON.stringify({ name: 'test-app' }));
@@ -27,8 +29,8 @@ it('clones stable source snapshots while resolving dependencies from the actual
 
   const fixture = createIsolatedPlayground(root, 'playground/react-pages');
   expect(readFileSync(join(fixture.root, 'page.ts'), 'utf8')).toBe('original source');
-  expect(realpathSync(join(fixture.root, 'node_modules'))).toBe(
-    realpathSync(join(source, 'node_modules')),
+  expect(realpathSync(join(fixture.root, 'node_modules', 'fixture-dependency'))).toBe(
+    realpathSync(join(source, 'node_modules', 'fixture-dependency')),
   );
   expect(readFileSync(join(source, 'page.ts'), 'utf8')).toBe('temporary HMR mutation');
   fixture.cleanup();

test/integration-helpers.ts

@@ -6,6 +6,8 @@ import {
   mkdirSync,
   mkdtempSync,
   readFileSync,
+  readdirSync,
+  realpathSync,
   rmSync,
   symlinkSync,
   writeFileSync,
@@ -80,18 +82,41 @@ export function createIsolatedPlayground(
     filter(path) {
       // `cpSync` reports native backslash paths on Windows, while these workspace paths are
       // normalized to forward slashes. Normalize before using the POSIX path helpers or the
-      // top-level `node_modules` junction is copied and the replacement junction already exists.
+      // top-level `node_modules` directory is copied into the isolated dependency tree.
       return shouldCopyPlaygroundPath(copySource, path);
     },
   });
 
   const sourceNodeModules = join(sourceRoot, 'node_modules');
   if (existsSync(sourceNodeModules)) {
-    symlinkSync(
-      sourceNodeModules,
-      join(root, 'node_modules'),
-      process.platform === 'win32' ? 'junction' : 'dir',
-    );
+    const fixtureNodeModules = join(root, 'node_modules');
+    mkdirSync(fixtureNodeModules);
+    const linkDependency = (source: string, destination: string) =>
+      symlinkSync(
+        realpathSync(source),
+        destination,
+        process.platform === 'win32' ? 'junction' : 'dir',
+      );
+    // Linking the whole directory leaves pnpm's relative package links behind
+    // a Windows junction at a different depth. Pin each package's real target.
+    for (const entry of readdirSync(sourceNodeModules, { withFileTypes: true })) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) {
+        continue;
+      }
+      if (entry.name.startsWith('.') && entry.name !== '.bin') {
+        continue;
+      }
+      const source = join(sourceNodeModules, entry.name);
+      const destination = join(fixtureNodeModules, entry.name);
+      if (entry.name.startsWith('@')) {
+        mkdirSync(destination);
+        for (const name of readdirSync(source)) {
+          linkDependency(join(source, name), join(destination, name));
+        }
+      } else {
+        linkDependency(source, destination);
+      }
+    }
   }
 
   // Avoid duplicate workspace package names when multiple copies exist concurrently.