Feature: Expose esm hooks factory to public API

src/esm.ts

@@ -1,4 +1,4 @@
-import { register, getExtensions, RegisterOptions } from './index';
+import { getExtensions, register, RegisterOptions, Service } from './index';
 import {
   parse as parseUrl,
   format as formatUrl,
@@ -15,17 +15,22 @@ const {
 
 // Note: On Windows, URLs look like this: file:///D:/dev/@TypeStrong/ts-node-examples/foo.ts
 
+/** @internal */
 export function registerAndCreateEsmHooks(opts?: RegisterOptions) {
   // Automatically performs registration just like `-r ts-node/register`
   const tsNodeInstance = register({
     ...opts,
     experimentalEsmLoader: true,
   });
 
+  return createEsmHooks(tsNodeInstance);
+}
+
+export function createEsmHooks(tsNodeService: Service) {
   // Custom implementation that considers additional file extensions and automatically adds file extensions
   const nodeResolveImplementation = createResolve({
-    ...getExtensions(tsNodeInstance.config),
-    preferTsExts: tsNodeInstance.options.preferTsExts,
+    ...getExtensions(tsNodeService.config),
+    preferTsExts: tsNodeService.options.preferTsExts,
   });
 
   return { resolve, getFormat, transformSource };
@@ -98,17 +103,17 @@ export function registerAndCreateEsmHooks(opts?: RegisterOptions) {
     // If file has .ts, .tsx, or .jsx extension, then ask node how it would treat this file if it were .js
     const ext = extname(nativePath);
     let nodeSays: { format: Format };
-    if (ext !== '.js' && !tsNodeInstance.ignored(nativePath)) {
+    if (ext !== '.js' && !tsNodeService.ignored(nativePath)) {
       nodeSays = await defer(formatUrl(pathToFileURL(nativePath + '.js')));
     } else {
       nodeSays = await defer();
     }
     // For files compiled by ts-node that node believes are either CJS or ESM, check if we should override that classification
     if (
-      !tsNodeInstance.ignored(nativePath) &&
+      !tsNodeService.ignored(nativePath) &&
       (nodeSays.format === 'commonjs' || nodeSays.format === 'module')
     ) {
-      const { moduleType } = tsNodeInstance.moduleTypeClassifier.classifyModule(
+      const { moduleType } = tsNodeService.moduleTypeClassifier.classifyModule(
         normalizeSlashes(nativePath)
       );
       if (moduleType === 'cjs') {
@@ -139,11 +144,11 @@ export function registerAndCreateEsmHooks(opts?: RegisterOptions) {
     }
     const nativePath = fileURLToPath(url);
 
-    if (tsNodeInstance.ignored(nativePath)) {
+    if (tsNodeService.ignored(nativePath)) {
       return defer();
     }
 
-    const emittedJs = tsNodeInstance.compile(sourceAsString, nativePath);
+    const emittedJs = tsNodeService.compile(sourceAsString, nativePath);
 
     return { source: emittedJs };
   }

src/index.ts

@@ -1430,3 +1430,8 @@ function getTokenAtPosition(
     return current;
   }
 }
+
+import type { createEsmHooks as createEsmHooksFn } from './esm';
+export const createEsmHooks: typeof createEsmHooksFn = (
+  tsNodeService: Service
+) => require('./esm').createEsmHooks(tsNodeService);

src/test/index.spec.ts

@@ -1867,6 +1867,25 @@ test.suite('ts-node', (test) => {
     });
   });
 
+  test.suite('createEsmHooks', (test) => {
+    if (semver.gte(process.version, '12.0.0')) {
+      test('should create proper hooks with provided instance', async () => {
+        const { err } = await exec(
+          `node ${experimentalModulesFlag} --loader ./loader.mjs index.ts`,
+          {
+            cwd: join(TEST_DIR, './esm-custom-loader'),
+          }
+        );
+
+        if (err === null) {
+          throw new Error('Command was expected to fail, but it succeeded.');
+        }
+
+        expect(err.message).to.match(/TS6133:\s+'unusedVar'/);
+      });
+    }
+  });
+
   test.suite('esm', (test) => {
     if (semver.gte(process.version, '12.16.0')) {
       test('should compile and execute as ESM', async () => {

tests/esm-custom-loader/index.ts

@@ -0,0 +1,4 @@
+export function abc() {
+  let unusedVar: string;
+  return true;
+}

tests/esm-custom-loader/loader.mjs

@@ -0,0 +1,17 @@
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+const require = createRequire(fileURLToPath(import.meta.url));
+
+/** @type {import('../../dist')} **/
+const { createEsmHooks, register } = require('ts-node');
+
+const tsNodeInstance = register({
+  compilerOptions: {
+    noUnusedLocals: true,
+  },
+  experimentalEsmLoader: true,
+});
+
+export const { resolve, getFormat, transformSource } = createEsmHooks(
+  tsNodeInstance
+);

tests/esm-custom-loader/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

tests/esm-custom-loader/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "noUnusedLocals": false
+  }
+}