chore: migrate resolve and resolve.exports to unrs-resolver

close #15600

Author: JounQin

packages/jest-resolve/package.json

@@ -22,17 +22,13 @@
     "chalk": "^4.0.0",
     "graceful-fs": "^4.2.9",
     "jest-haste-map": "workspace:*",
-    "jest-pnp-resolver": "^1.2.2",
     "jest-util": "workspace:*",
     "jest-validate": "workspace:*",
-    "resolve": "^1.20.0",
-    "resolve.exports": "^2.0.0",
-    "slash": "^3.0.0"
+    "slash": "^3.0.0",
+    "unrs-resolver": "^1.7.2"
   },
   "devDependencies": {
-    "@types/graceful-fs": "^4.1.3",
-    "@types/pnpapi": "^0.0.5",
-    "@types/resolve": "^1.20.2"
+    "@types/graceful-fs": "^4.1.3"
   },
   "engines": {
     "node": "^16.10.0 || ^18.12.0 || >=20.0.0"

packages/jest-resolve/src/defaultResolver.ts

@@ -5,21 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {dirname, isAbsolute, resolve as pathResolve} from 'path';
-import {fileURLToPath} from 'url';
-import pnpResolver from 'jest-pnp-resolver';
 import {
-  type SyncOpts as UpstreamResolveOptions,
-  sync as resolveSync,
-} from 'resolve';
-import * as resolve from 'resolve.exports';
-import {
-  findClosestPackageJson,
-  isDirectory,
-  isFile,
-  readPackageCached,
-  realpathSync,
-} from './fileWalkers';
+  ResolverFactory,
+  type NapiResolveOptions as UpstreamResolveOptions,
+} from 'unrs-resolver';
 import type {PackageJSON} from './types';
 
 /**
@@ -52,15 +41,13 @@ export type PathFilter = (
   relativePath: string,
 ) => string;
 
-export type ResolverOptions = {
+export interface ResolverOptions extends UpstreamResolveOptions {
   /** Directory to begin resolving from. */
   basedir: string;
   /** List of export conditions. */
   conditions?: Array<string>;
   /** Instance of default resolver. */
   defaultResolver: typeof defaultResolver;
-  /** List of file extensions to search in order. */
-  extensions?: Array<string>;
   /**
    * List of directory names to be looked up for modules recursively.
    *
@@ -79,12 +66,7 @@ export type ResolverOptions = {
   packageFilter?: PackageFilter;
   /** Allows transforms a path within a package. */
   pathFilter?: PathFilter;
-  /** Current root directory. */
-  rootDir?: string;
-};
-
-type UpstreamResolveOptionsWithConditions = UpstreamResolveOptions &
-  ResolverOptions;
+}
 
 export type SyncResolver = (path: string, options: ResolverOptions) => string;
 export type AsyncResolver = (
@@ -95,159 +77,21 @@ export type AsyncResolver = (
 export type Resolver = SyncResolver | AsyncResolver;
 
 const defaultResolver: SyncResolver = (path, options) => {
-  // Yarn 2 adds support to `resolve` automatically so the pnpResolver is only
-  // needed for Yarn 1 which implements version 1 of the pnp spec
-  if (process.versions.pnp === '1') {
-    return pnpResolver(path, options);
-  }
-
-  const resolveOptions: UpstreamResolveOptionsWithConditions = {
+  const resolveOptions: UpstreamResolveOptions = {
     ...options,
-    isDirectory,
-    isFile,
-    preserveSymlinks: false,
-    readPackageSync,
-    realpathSync,
+    conditionNames: options.conditionNames || options.conditions,
+    modules: options.modules || options.moduleDirectory,
   };
 
-  const pathToResolve = getPathInModule(path, resolveOptions);
-
-  // resolveSync dereferences symlinks to ensure we don't create a separate
-  // module instance depending on how it was referenced.
-  const result = resolveSync(pathToResolve, resolveOptions);
-
-  return result;
-};
-
-export default defaultResolver;
-
-/*
- * helper functions
- */
-
-function readPackageSync(_: unknown, file: string): PackageJSON {
-  return readPackageCached(file);
-}
+  const unrsResolver = new ResolverFactory(resolveOptions);
 
-function getPathInModule(
-  path: string,
-  options: UpstreamResolveOptionsWithConditions,
-): string {
-  if (path.startsWith('file://')) {
-    path = fileURLToPath(path);
-  }
+  const result = unrsResolver.sync(options.basedir, path);
 
-  if (shouldIgnoreRequestForExports(path)) {
-    return path;
+  if (result.error) {
+    throw new Error(result.error);
   }
 
-  if (path.startsWith('#')) {
-    const closestPackageJson = findClosestPackageJson(options.basedir);
-
-    if (!closestPackageJson) {
-      throw new Error(
-        `Jest: unable to locate closest package.json from ${options.basedir} when resolving import "${path}"`,
-      );
-    }
-
-    const pkg = readPackageCached(closestPackageJson);
-
-    const resolved = resolve.imports(
-      pkg,
-      path as resolve.Imports.Entry,
-      createResolveOptions(options.conditions),
-    );
-
-    if (resolved) {
-      const target = resolved[0];
-      return target.startsWith('.')
-        ? // internal relative filepath
-          pathResolve(dirname(closestPackageJson), target)
-        : // this is an external module, re-resolve it
-          defaultResolver(target, options);
-    }
-
-    if (pkg.imports) {
-      throw new Error(
-        '`imports` exists, but no results - this is a bug in Jest. Please report an issue',
-      );
-    }
-  }
-
-  const segments = path.split('/');
-
-  let moduleName = segments.shift();
-
-  if (moduleName) {
-    if (moduleName.startsWith('@')) {
-      moduleName = `${moduleName}/${segments.shift()}`;
-    }
-
-    // self-reference
-    const closestPackageJson = findClosestPackageJson(options.basedir);
-    if (closestPackageJson) {
-      const pkg = readPackageCached(closestPackageJson);
-
-      if (pkg.name === moduleName) {
-        const resolved = resolve.exports(
-          pkg,
-          (segments.join('/') || '.') as resolve.Exports.Entry,
-          createResolveOptions(options.conditions),
-        );
-
-        if (resolved) {
-          return pathResolve(dirname(closestPackageJson), resolved[0]);
-        }
-
-        if (pkg.exports) {
-          throw new Error(
-            '`exports` exists, but no results - this is a bug in Jest. Please report an issue',
-          );
-        }
-      }
-    }
-
-    let packageJsonPath = '';
-
-    try {
-      packageJsonPath = resolveSync(`${moduleName}/package.json`, options);
-    } catch {
-      // ignore if package.json cannot be found
-    }
-
-    if (packageJsonPath && isFile(packageJsonPath)) {
-      const pkg = readPackageCached(packageJsonPath);
-
-      const resolved = resolve.exports(
-        pkg,
-        (segments.join('/') || '.') as resolve.Exports.Entry,
-        createResolveOptions(options.conditions),
-      );
-
-      if (resolved) {
-        return pathResolve(dirname(packageJsonPath), resolved[0]);
-      }
-
-      if (pkg.exports) {
-        throw new Error(
-          '`exports` exists, but no results - this is a bug in Jest. Please report an issue',
-        );
-      }
-    }
-  }
-
-  return path;
-}
-
-function createResolveOptions(
-  conditions: Array<string> | undefined,
-): resolve.Options {
-  return conditions
-    ? {conditions, unsafe: true}
-    : // no conditions were passed - let's assume this is Jest internal and it should be `require`
-      {browser: false, require: true};
-}
+  return result.path!;
+};
 
-// if it's a relative import or an absolute path, imports/exports are ignored
-const shouldIgnoreRequestForExports = (path: string) =>
-  path.startsWith('.') || isAbsolute(path);
+export default defaultResolver;

packages/jest-resolve/src/resolver.ts

@@ -126,7 +126,6 @@ export default class Resolver {
         extensions: options.extensions,
         moduleDirectory: options.moduleDirectory,
         paths: paths ? [...(nodePaths || []), ...paths] : nodePaths,
-        rootDir: options.rootDir,
       });
     } catch (error) {
       // we always wanna throw if it's an internal import
@@ -169,7 +168,6 @@ export default class Resolver {
         extensions: options.extensions,
         moduleDirectory: options.moduleDirectory,
         paths: paths ? [...(nodePaths || []), ...paths] : nodePaths,
-        rootDir: options.rootDir,
       });
       return result;
     } catch (error: unknown) {