Add path mapping support to ESM and CJS loaders

src/esm.ts

@@ -11,11 +11,11 @@ import {
   UrlWithStringQuery,
   fileURLToPath,
   pathToFileURL,
+  URL,
 } from 'url';
 import { extname } from 'path';
 import * as assert from 'assert';
 import { normalizeSlashes } from './util';
-import { createPathMapper } from './path-mapping';
 const {
   createResolve,
 } = require('../dist-raw/node-esm-resolve-implementation');
@@ -106,7 +106,6 @@ export function registerAndCreateEsmHooks(opts?: RegisterOptions) {
 
 export function createEsmHooks(tsNodeService: Service) {
   tsNodeService.enableExperimentalEsmLoaderInterop();
-  const mapPath = createPathMapper(tsNodeService.config.options);
 
   // Custom implementation that considers additional file extensions and automatically adds file extensions
   const nodeResolveImplementation = createResolve({
@@ -165,8 +164,10 @@ export function createEsmHooks(tsNodeService: Service) {
 
     if (context.parentURL) {
       const parentUrl = new URL(context.parentURL);
-      if (parentUrl.pathname && extname(parentUrl.pathname) === '.ts') {
-        const mappedSpecifiers = mapPath(specifier);
+      const parentPath =
+        parentUrl.protocol === 'file:' && fileURLToPath(parentUrl);
+      if (parentPath && !tsNodeService.ignored(parentPath)) {
+        const mappedSpecifiers = tsNodeService.mapPath(specifier);
         if (mappedSpecifiers) {
           candidateSpecifiers = mappedSpecifiers.map((path) =>
             pathToFileURL(path).toString()
@@ -175,26 +176,33 @@ export function createEsmHooks(tsNodeService: Service) {
       }
     }
 
-    let candidateSpecifier: string | undefined;
-    while ((candidateSpecifier = candidateSpecifiers.shift())) {
+    for (let i = 0; i < candidateSpecifiers.length; i++) {
       try {
         return await nodeResolveImplementation.defaultResolve(
-          candidateSpecifier,
+          candidateSpecifiers[i],
           context,
           defaultResolve
         );
       } catch (err) {
-        const isNotFoundError = (<any>err).code === 'ERR_MODULE_NOT_FOUND';
-        if (isNotFoundError && candidateSpecifiers.length > 0) {
-          continue;
-        } else {
+        const isNotFoundError = (err as any).code === 'ERR_MODULE_NOT_FOUND';
+        if (!isNotFoundError) {
           throw err;
+        } else if (i == candidateSpecifiers.length - 1) {
+          throw new MappedModuleNotFound(
+            specifier,
+            context.parentURL,
+            candidateSpecifiers
+          );
+        } else {
+          continue;
         }
       }
     }
 
+    // This code should be unreachable: The for-loop always returns or
+    // throws.
     throw new Error(
-      `Empty mapped paths for ${specifier} imported from ${context.parentURL}`
+      `Unreachable code mapping ${specifier} in ${context.parentURL}`
     );
   }
 
@@ -332,3 +340,19 @@ export function createEsmHooks(tsNodeService: Service) {
     return { source: emittedJs };
   }
 }
+
+class MappedModuleNotFound extends Error {
+  // Same code as other module not found errors.
+  static code = 'ERR_MODULE_NOT_FOUND';
+
+  constructor(specifier: string, base: string, candidates: string[]) {
+    super(
+      [
+        `Cannot find '${specifier}' imported from ${base} using TypeScript path mapping`,
+        'Candidates attempted:',
+        ...candidates.map((candidate) => `- ${candidate}`),
+      ].join('\n')
+    );
+    this.name = `Error [${MappedModuleNotFound.code}]`;
+  }
+}

src/index.ts

@@ -25,6 +25,7 @@ import {
 } from './module-type-classifier';
 import { createResolverFunctions } from './resolver-functions';
 import type { createEsmHooks as createEsmHooksFn } from './esm';
+import { createPathMapper } from './path-mapping';
 
 export { TSCommon };
 export {
@@ -482,6 +483,14 @@ export interface Service {
   enableExperimentalEsmLoaderInterop(): void;
   /** @internal */
   transpileOnly: boolean;
+  /**
+   * @internal
+   *
+   * Map import paths to candidates according to the `paths` compiler
+   * option. Returns `null` if the specifier did not match and was not
+   * mapped.
+   */
+  mapPath(specifier: string): string[] | null;
 }
 
 /**
@@ -1318,6 +1327,8 @@ export function create(rawOptions: CreateOptions = {}): Service {
     });
   }
 
+  const mapPath = createPathMapper(config.options);
+
   return {
     [TS_NODE_SERVICE_BRAND]: true,
     ts,
@@ -1334,6 +1345,7 @@ export function create(rawOptions: CreateOptions = {}): Service {
     installSourceMapSupport,
     enableExperimentalEsmLoaderInterop,
     transpileOnly,
+    mapPath,
   };
 }
 

src/test/index.spec.ts

@@ -1234,6 +1234,22 @@ test.suite('ts-node', (test) => {
         );
         expect(err).toBe(null);
       });
+
+      test('path mapping error candidates', async () => {
+        const { stderr, err } = await exec(
+          `${CMD_ESM_LOADER_WITHOUT_PROJECT} mapped-not-found.ts`,
+          {
+            cwd: join(TEST_DIR, './esm-path-mapping'),
+          }
+        );
+        expect(err).toBeTruthy();
+        expect(stderr).toMatch(
+          "[ERR_MODULE_NOT_FOUND]: Cannot find 'map2/does-not-exist.ts'"
+        );
+        // Expect tried candidates to be listed
+        expect(stderr).toMatch(/- file:\/\/.*mapped\/2-does-not-exist.ts/);
+        expect(stderr).toMatch(/- file:\/\/.*mapped\/2a-does-not-exist.ts/);
+      });
     }
 
     if (semver.gte(process.version, '12.0.0')) {

tests/esm-path-mapping/index-js.js

@@ -0,0 +1,4 @@
+import * as assert from 'assert';
+
+import map1foo from 'map1/foo.js';
+assert.equal(map1foo, 'mapped/1-foo');

tests/esm-path-mapping/index-tsx.tsx

@@ -0,0 +1,4 @@
+import * as assert from 'assert';
+
+import map1foo from 'map1/foo.js';
+assert.equal(map1foo, 'mapped/1-foo');

tests/esm-path-mapping/index.ts

@@ -23,6 +23,10 @@ import map2specific from 'map2/specific/foo.js';
 // Path is mapped when using no wildcard
 import mapStatic from 'static';
 
+// Test path mapping in `.tsx` and `.js` files.
+import './index-tsx.tsx';
+import './index-js.js';
+
 assert.equal(map1foo, 'mapped/1-foo');
 assert.equal(map1jsx, 'mapped/1-jsx');
 assert.equal(map2foo, 'mapped/2-foo');

tests/esm-path-mapping/mapped-not-found.ts

@@ -0,0 +1 @@
+import 'map2/does-not-exist.ts';

tests/esm-path-mapping/tsconfig.json

@@ -1,4 +1,5 @@
 {
+  "include": ["**/*.ts", "**/*.mts", "**/*.tsx", "**/*.js", "**/*.jsx"],
   "compilerOptions": {
     "module": "ESNext",
     "allowJs": true,