run lint-fix

esm.mjs

@@ -4,9 +4,5 @@ const require = createRequire(fileURLToPath(import.meta.url));
 
 /** @type {import('./dist/esm')} */
 const esm = require('./dist/esm');
-export const {
-  resolve,
-  load,
-  getFormat,
-  transformSource,
-} = esm.registerAndCreateEsmHooks();
+export const { resolve, load, getFormat, transformSource } =
+  esm.registerAndCreateEsmHooks();

esm/transpile-only.mjs

@@ -4,9 +4,5 @@ const require = createRequire(fileURLToPath(import.meta.url));
 
 /** @type {import('../dist/esm')} */
 const esm = require('../dist/esm');
-export const {
-  resolve,
-  load,
-  getFormat,
-  transformSource,
-} = esm.registerAndCreateEsmHooks({ transpileOnly: true });
+export const { resolve, load, getFormat, transformSource } =
+  esm.registerAndCreateEsmHooks({ transpileOnly: true });

scripts/create-merged-schema.ts

@@ -37,8 +37,7 @@ async function main() {
                   .compilerOptions,
                 allOf: [
                   {
-                    $ref:
-                      '#/definitions/compilerOptionsDefinition/properties/compilerOptions',
+                    $ref: '#/definitions/compilerOptionsDefinition/properties/compilerOptions',
                   },
                 ],
               },
@@ -62,9 +61,7 @@ async function main() {
 }
 
 export async function getSchemastoreSchema() {
-  const {
-    data: schemastoreSchema,
-  } = await axios.get(
+  const { data: schemastoreSchema } = await axios.get(
     'https://schemastore.azurewebsites.net/schemas/json/tsconfig.json',
     { responseType: 'json' }
   );

src/bin.ts

@@ -292,7 +292,7 @@ export function main(
   }
 
   if (showConfig) {
-    const ts = (service.ts as any) as TSInternal;
+    const ts = service.ts as any as TSInternal;
     if (typeof ts.convertToTSConfig !== 'function') {
       console.error(
         'Error: --show-config requires a typescript versions >=3.2 that support --showConfig'

src/configuration.ts

@@ -142,7 +142,7 @@ export function readConfig(
           },
           bp,
           errors,
-          ((ts as unknown) as TSInternal).createCompilerDiagnostic
+          (ts as unknown as TSInternal).createCompilerDiagnostic
         );
         if (errors.length) {
           return {
@@ -165,8 +165,9 @@ export function readConfig(
   const optionBasePaths: OptionBasePaths = {};
   for (let i = configChain.length - 1; i >= 0; i--) {
     const { config, basePath, configPath } = configChain[i];
-    const options = filterRecognizedTsConfigTsNodeOptions(config['ts-node'])
-      .recognized;
+    const options = filterRecognizedTsConfigTsNodeOptions(
+      config['ts-node']
+    ).recognized;
 
     // Some options are relative to the config file, so must be converted to absolute paths here
     if (options.require) {
@@ -250,9 +251,7 @@ export function readConfig(
  * Given the raw "ts-node" sub-object from a tsconfig, return an object with only the properties
  * recognized by "ts-node"
  */
-function filterRecognizedTsConfigTsNodeOptions(
-  jsonObject: any
-): {
+function filterRecognizedTsConfigTsNodeOptions(jsonObject: any): {
   recognized: TsConfigOptions;
   unrecognized: any;
 } {
@@ -303,7 +302,9 @@ function filterRecognizedTsConfigTsNodeOptions(
     swc,
   };
   // Use the typechecker to make sure this implementation has the correct set of properties
-  const catchExtraneousProps: keyof TsConfigOptions = (null as any) as keyof typeof filteredTsConfigOptions;
-  const catchMissingProps: keyof typeof filteredTsConfigOptions = (null as any) as keyof TsConfigOptions;
+  const catchExtraneousProps: keyof TsConfigOptions =
+    null as any as keyof typeof filteredTsConfigOptions;
+  const catchMissingProps: keyof typeof filteredTsConfigOptions =
+    null as any as keyof TsConfigOptions;
   return { recognized: filteredTsConfigOptions, unrecognized };
 }

src/index.ts

@@ -577,12 +577,8 @@ export function create(rawOptions: CreateOptions = {}): Service {
   );
 
   // Read config file and merge new options between env and CLI options.
-  const {
-    configFilePath,
-    config,
-    tsNodeOptionsFromTsconfig,
-    optionBasePaths,
-  } = readConfig(cwd, ts, rawOptions);
+  const { configFilePath, config, tsNodeOptionsFromTsconfig, optionBasePaths } =
+    readConfig(cwd, ts, rawOptions);
   const options = assign<RegisterOptions>(
     {},
     DEFAULTS,
@@ -817,9 +813,9 @@ export function create(rawOptions: CreateOptions = {}): Service {
     _position: number
   ) => TypeInfo;
 
-  const getCanonicalFileName = ((ts as unknown) as TSInternal).createGetCanonicalFileName(
-    ts.sys.useCaseSensitiveFileNames
-  );
+  const getCanonicalFileName = (
+    ts as unknown as TSInternal
+  ).createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames);
 
   const moduleTypeClassifier = createModuleTypeClassifier({
     basePath: options.optionBasePaths?.moduleTypes,
@@ -908,8 +904,10 @@ export function create(rawOptions: CreateOptions = {}): Service {
         configFilePath,
       });
       serviceHost.resolveModuleNames = resolveModuleNames;
-      serviceHost.getResolvedModuleWithFailedLookupLocationsFromCache = getResolvedModuleWithFailedLookupLocationsFromCache;
-      serviceHost.resolveTypeReferenceDirectives = resolveTypeReferenceDirectives;
+      serviceHost.getResolvedModuleWithFailedLookupLocationsFromCache =
+        getResolvedModuleWithFailedLookupLocationsFromCache;
+      serviceHost.resolveTypeReferenceDirectives =
+        resolveTypeReferenceDirectives;
 
       const registry = ts.createDocumentRegistry(
         ts.sys.useCaseSensitiveFileNames,
@@ -1272,9 +1270,8 @@ export function create(rawOptions: CreateOptions = {}): Service {
   // Create a simple TypeScript compiler proxy.
   function compile(code: string, fileName: string, lineOffset = 0) {
     const normalizedFileName = normalizeSlashes(fileName);
-    const classification = moduleTypeClassifier.classifyModule(
-      normalizedFileName
-    );
+    const classification =
+      moduleTypeClassifier.classifyModule(normalizedFileName);
     // Must always call normal getOutput to throw typechecking errors
     let [value, sourceMap] = getOutput(code, normalizedFileName);
     // If module classification contradicts the above, call the relevant transpiler

src/resolver-functions.ts

@@ -13,14 +13,8 @@ export function createResolverFunctions(kwargs: {
   config: _ts.ParsedCommandLine;
   configFilePath: string | undefined;
 }) {
-  const {
-    host,
-    ts,
-    config,
-    cwd,
-    getCanonicalFileName,
-    configFilePath,
-  } = kwargs;
+  const { host, ts, config, cwd, getCanonicalFileName, configFilePath } =
+    kwargs;
   const moduleResolutionCache = ts.createModuleResolutionCache(
     cwd,
     getCanonicalFileName,
@@ -105,69 +99,71 @@ export function createResolverFunctions(kwargs: {
   };
 
   // language service never calls this, but TS docs recommend that we implement it
-  const getResolvedModuleWithFailedLookupLocationsFromCache: _ts.LanguageServiceHost['getResolvedModuleWithFailedLookupLocationsFromCache'] = (
-    moduleName,
-    containingFile
-  ): _ts.ResolvedModuleWithFailedLookupLocations | undefined => {
-    const ret = ts.resolveModuleNameFromCache(
+  const getResolvedModuleWithFailedLookupLocationsFromCache: _ts.LanguageServiceHost['getResolvedModuleWithFailedLookupLocationsFromCache'] =
+    (
       moduleName,
-      containingFile,
-      moduleResolutionCache
-    );
-    if (ret && ret.resolvedModule) {
-      fixupResolvedModule(ret.resolvedModule);
-    }
-    return ret;
-  };
-
-  const resolveTypeReferenceDirectives: _ts.LanguageServiceHost['resolveTypeReferenceDirectives'] = (
-    typeDirectiveNames: string[],
-    containingFile: string,
-    redirectedReference: _ts.ResolvedProjectReference | undefined,
-    options: _ts.CompilerOptions
-  ): (_ts.ResolvedTypeReferenceDirective | undefined)[] => {
-    // Note: seems to be called with empty typeDirectiveNames array for all files.
-    return typeDirectiveNames.map((typeDirectiveName) => {
-      let { resolvedTypeReferenceDirective } = ts.resolveTypeReferenceDirective(
-        typeDirectiveName,
+      containingFile
+    ): _ts.ResolvedModuleWithFailedLookupLocations | undefined => {
+      const ret = ts.resolveModuleNameFromCache(
+        moduleName,
         containingFile,
-        config.options,
-        host,
-        redirectedReference
+        moduleResolutionCache
       );
-      if (typeDirectiveName === 'node' && !resolvedTypeReferenceDirective) {
-        // Resolve @types/node relative to project first, then __dirname (copy logic from elsewhere / refactor into reusable function)
-        let typesNodePackageJsonPath: string | undefined;
-        try {
-          typesNodePackageJsonPath = require.resolve(
-            '@types/node/package.json',
-            {
-              paths: [configFilePath ?? cwd, __dirname],
-            }
-          );
-        } catch {} // gracefully do nothing when @types/node is not installed for any reason
-        if (typesNodePackageJsonPath) {
-          const typeRoots = [resolve(typesNodePackageJsonPath, '../..')];
-          ({
-            resolvedTypeReferenceDirective,
-          } = ts.resolveTypeReferenceDirective(
+      if (ret && ret.resolvedModule) {
+        fixupResolvedModule(ret.resolvedModule);
+      }
+      return ret;
+    };
+
+  const resolveTypeReferenceDirectives: _ts.LanguageServiceHost['resolveTypeReferenceDirectives'] =
+    (
+      typeDirectiveNames: string[],
+      containingFile: string,
+      redirectedReference: _ts.ResolvedProjectReference | undefined,
+      options: _ts.CompilerOptions
+    ): (_ts.ResolvedTypeReferenceDirective | undefined)[] => {
+      // Note: seems to be called with empty typeDirectiveNames array for all files.
+      return typeDirectiveNames.map((typeDirectiveName) => {
+        let { resolvedTypeReferenceDirective } =
+          ts.resolveTypeReferenceDirective(
             typeDirectiveName,
             containingFile,
-            {
-              ...config.options,
-              typeRoots,
-            },
+            config.options,
             host,
             redirectedReference
-          ));
+          );
+        if (typeDirectiveName === 'node' && !resolvedTypeReferenceDirective) {
+          // Resolve @types/node relative to project first, then __dirname (copy logic from elsewhere / refactor into reusable function)
+          let typesNodePackageJsonPath: string | undefined;
+          try {
+            typesNodePackageJsonPath = require.resolve(
+              '@types/node/package.json',
+              {
+                paths: [configFilePath ?? cwd, __dirname],
+              }
+            );
+          } catch {} // gracefully do nothing when @types/node is not installed for any reason
+          if (typesNodePackageJsonPath) {
+            const typeRoots = [resolve(typesNodePackageJsonPath, '../..')];
+            ({ resolvedTypeReferenceDirective } =
+              ts.resolveTypeReferenceDirective(
+                typeDirectiveName,
+                containingFile,
+                {
+                  ...config.options,
+                  typeRoots,
+                },
+                host,
+                redirectedReference
+              ));
+          }
         }
-      }
-      if (resolvedTypeReferenceDirective) {
-        fixupResolvedModule(resolvedTypeReferenceDirective);
-      }
-      return resolvedTypeReferenceDirective;
-    });
-  };
+        if (resolvedTypeReferenceDirective) {
+          fixupResolvedModule(resolvedTypeReferenceDirective);
+        }
+        return resolvedTypeReferenceDirective;
+      });
+    };
 
   return {
     resolveModuleNames,

src/test/index.spec.ts

@@ -1086,21 +1086,15 @@ test.suite('ts-node', (test) => {
 
       test.suite('supports experimental-specifier-resolution=node', (test) => {
         test('via --experimental-specifier-resolution', async () => {
-          const {
-            err,
-            stdout,
-          } = await exec(
+          const { err, stdout } = await exec(
             `${CMD_ESM_LOADER_WITHOUT_PROJECT} --experimental-specifier-resolution=node index.ts`,
             { cwd: join(TEST_DIR, './esm-node-resolver') }
           );
           expect(err).toBe(null);
           expect(stdout).toBe('foo bar baz biff libfoo\n');
         });
         test('via --es-module-specifier-resolution alias', async () => {
-          const {
-            err,
-            stdout,
-          } = await exec(
+          const { err, stdout } = await exec(
             `${CMD_ESM_LOADER_WITHOUT_PROJECT} ${EXPERIMENTAL_MODULES_FLAG} --es-module-specifier-resolution=node index.ts`,
             { cwd: join(TEST_DIR, './esm-node-resolver') }
           );

src/test/register.spec.ts

@@ -12,7 +12,8 @@ import * as exp from 'expect';
 import { join, resolve } from 'path';
 import proxyquire = require('proxyquire');
 
-const SOURCE_MAP_REGEXP = /\/\/# sourceMappingURL=data:application\/json;charset=utf\-8;base64,[\w\+]+=*$/;
+const SOURCE_MAP_REGEXP =
+  /\/\/# sourceMappingURL=data:application\/json;charset=utf\-8;base64,[\w\+]+=*$/;
 
 const createOptions: tsNodeTypes.CreateOptions = {
   project: PROJECT,

src/test/repl/helpers.ts

@@ -39,9 +39,9 @@ export async function contextReplHelpers(
       stderr,
       ...createReplOpts,
     });
-    const service = (registerHooks
-      ? tsNodeUnderTest.register
-      : tsNodeUnderTest.create)({
+    const service = (
+      registerHooks ? tsNodeUnderTest.register : tsNodeUnderTest.create
+    )({
       ...replService.evalAwarePartialHost,
       project: `${TEST_DIR}/tsconfig.json`,
       ...createServiceOpts,

src/test/repl/node-repl-tla.ts

@@ -39,9 +39,11 @@ export async function upstreamTopLevelAwaitTests({
     },
   });
   replService.setService(service);
-  (replService.stdout as NodeJS.WritableStream & {
-    isTTY: boolean;
-  }).isTTY = true;
+  (
+    replService.stdout as NodeJS.WritableStream & {
+      isTTY: boolean;
+    }
+  ).isTTY = true;
   const replServer = replService.startInternal({
     prompt: PROMPT,
     terminal: true,