feat: support compile js files

Author: yeliex

package.json

@@ -87,6 +87,7 @@
   },
   "ava": {
     "extensions": [
+      "js",
       "ts",
       "tsx"
     ],
@@ -95,7 +96,7 @@
     ],
     "cache": false,
     "files": [
-      "packages/**/*.spec.{ts,tsx}"
+      "packages/**/*.spec.{js,ts,tsx}"
     ],
     "environmentVariables": {
       "SWC_NODE_PROJECT": "./tsconfig.test.json"

packages/integrate-module/src/index.ts

@@ -7,6 +7,8 @@ import { supportedExtensions } from 'file-type'
 import { foo } from './foo.mjs'
 import { bar } from './subdirectory/bar.mjs'
 import { baz } from './subdirectory/index.mjs'
+import { bar as subBar } from '@subdirectory/bar.mjs'
+import './js-module.mjs'
 
 await test('file-type should work', () => {
   assert.ok(supportedExtensions.has('jpg'))
@@ -23,3 +25,7 @@ await test('resolve nested file path', () => {
 await test('resolve nested entry point', () => {
   assert.equal(baz(), 'baz')
 })
+
+await test('resolve paths', () => {
+  assert.equal(subBar(), 'bar')
+})

packages/integrate-module/src/js-module.mjs

@@ -0,0 +1,30 @@
+/* eslint import/order: off */
+import assert from 'node:assert'
+import test from 'node:test'
+
+import { supportedExtensions } from 'file-type'
+
+import { foo } from './foo.mts'
+import { bar } from './subdirectory/bar.mts'
+import { baz } from './subdirectory/index.mts'
+import { bar as subBar } from '@subdirectory/bar.mts'
+
+await test('js:file-type should work', () => {
+  assert.ok(supportedExtensions.has('jpg'))
+})
+
+await test('js:resolve adjacent file path', () => {
+  assert.equal(foo(), 'foo')
+})
+
+await test('js:resolve nested file path', () => {
+  assert.equal(bar(), 'bar')
+})
+
+await test('js:resolve nested entry point', () => {
+  assert.equal(baz(), 'baz')
+})
+
+await test('js:resolve paths', () => {
+  assert.equal(subBar(), 'bar')
+})

packages/integrate-module/tsconfig.json

@@ -4,7 +4,11 @@
     "target": "ESNext",
     "module": "ESNext",
     "composite": true,
-    "outDir": "dist"
+    "outDir": "dist",
+    "baseUrl": "./",
+    "paths": {
+      "@subdirectory/*": ["./src/subdirectory/*"],
+    },
   },
-  "include": ["src"]
+  "include": ["src"],
 }

packages/integrate/__tests__/paths/js-paths.spec.js

@@ -0,0 +1,6 @@
+import { FIXTURE } from '@integrate/fixture'
+import test from 'ava'
+
+test('js should transpile paths', (t) => {
+  t.is(FIXTURE, 'fixture')
+})

packages/register/esm.mts

@@ -1,29 +1,12 @@
+import type { LoadHook, ResolveHook } from 'node:module'
 import { fileURLToPath, pathToFileURL } from 'url'
 
 import ts from 'typescript'
 
 // @ts-expect-error
 import { readDefaultTsConfig } from '../lib/read-default-tsconfig.js'
 // @ts-expect-error
-import { compile } from '../lib/register.js'
-
-interface ResolveContext {
-  conditions: string[]
-  parentURL: string | undefined
-}
-
-interface ResolveResult {
-  format?: string
-  shortCircuit?: boolean
-  url: string
-}
-
-type ResolveArgs = [
-  specifier: string,
-  context?: ResolveContext,
-  nextResolve?: (...args: ResolveArgs) => Promise<ResolveResult>,
-]
-type ResolveFn = (...args: Required<ResolveArgs>) => Promise<ResolveResult>
+import { AVAILABLE_EXTENSION_PATTERN, AVAILABLE_TS_EXTENSION_PATTERN, compile } from '../lib/register.js'
 
 const tsconfig: ts.CompilerOptions = readDefaultTsConfig()
 tsconfig.module = ts.ModuleKind.ESNext
@@ -33,25 +16,24 @@ const host: ts.ModuleResolutionHost = {
   fileExists: ts.sys.fileExists,
   readFile: ts.sys.readFile,
 }
-const EXTENSIONS: string[] = [ts.Extension.Ts, ts.Extension.Tsx, ts.Extension.Mts]
 
-export const resolve: ResolveFn = async (specifier, context, nextResolve) => {
-  const isTS = EXTENSIONS.some((ext) => specifier.endsWith(ext))
+export const resolve: ResolveHook = async (specifier, context, nextResolve) => {
+  if (!AVAILABLE_EXTENSION_PATTERN.test(specifier)) {
+    return nextResolve(specifier)
+  }
 
   // entrypoint
   if (!context.parentURL) {
     return {
-      format: isTS ? 'ts' : undefined,
+      importAttributes: {
+        ...context.importAttributes,
+        swc: 'entrypoint',
+      },
       url: specifier,
       shortCircuit: true,
     }
   }
 
-  // import/require from external library
-  if (context.parentURL.includes('/node_modules/') && !isTS) {
-    return nextResolve(specifier)
-  }
-
   const { resolvedModule } = ts.resolveModuleName(
     specifier.startsWith('file:') ? fileURLToPath(specifier) : specifier,
     fileURLToPath(context.parentURL),
@@ -60,50 +42,44 @@ export const resolve: ResolveFn = async (specifier, context, nextResolve) => {
     moduleResolutionCache,
   )
 
-  // import from local project to local project TS file
+  // local project file
   if (
     resolvedModule &&
-    !resolvedModule.resolvedFileName.includes('/node_modules/') &&
-    EXTENSIONS.includes(resolvedModule.extension)
+    (!resolvedModule.resolvedFileName.includes('/node_modules/') ||
+      AVAILABLE_TS_EXTENSION_PATTERN.test(resolvedModule.resolvedFileName))
   ) {
     return {
-      format: 'ts',
       url: pathToFileURL(resolvedModule.resolvedFileName).href,
       shortCircuit: true,
+      importAttributes: {
+        ...context.importAttributes,
+        swc: resolvedModule.resolvedFileName,
+      },
     }
   }
 
-  // import from local project to either:
-  // - something TS couldn't resolve
-  // - external library
-  // - local project non-TS file
+  // files could not resolved by typescript
   return nextResolve(specifier)
 }
 
-interface LoadContext {
-  conditions: string[]
-  format: string | null | undefined
-}
-
-interface LoadResult {
-  format: string
-  shortCircuit?: boolean
-  source: string | ArrayBuffer | SharedArrayBuffer | Uint8Array
-}
-
-type LoadArgs = [url: string, context: LoadContext, nextLoad?: (...args: LoadArgs) => Promise<LoadResult>]
-type LoadFn = (...args: Required<LoadArgs>) => Promise<LoadResult>
-
 const tsconfigForSWCNode = {
   ...tsconfig,
   paths: undefined,
   baseUrl: undefined,
 }
 
-export const load: LoadFn = async (url, context, nextLoad) => {
-  if (context.format === 'ts') {
-    const { source } = await nextLoad(url, context)
-    const code = typeof source === 'string' ? source : Buffer.from(source).toString()
+export const load: LoadHook = async (url, context, nextLoad) => {
+  const swcAttribute = context.importAttributes.swc
+
+  if (swcAttribute) {
+    delete context.importAttributes.swc
+
+    const { source } = await nextLoad(url, {
+      ...context,
+      format: 'ts' as any,
+    })
+
+    const code = !source || typeof source === 'string' ? source : Buffer.from(source).toString()
     const compiled = await compile(code, fileURLToPath(url), tsconfigForSWCNode, true)
     return {
       format: 'module',

packages/register/register.ts

@@ -1,15 +1,32 @@
-import { platform } from 'os'
-import { resolve } from 'path'
-
 import { Options, transform, transformSync } from '@swc-node/core'
 import { installSourceMapSupport, SourcemapMap } from '@swc-node/sourcemap-support'
 import { addHook } from 'pirates'
 import * as ts from 'typescript'
 
 import { readDefaultTsConfig, tsCompilerOptionsToSwcConfig } from './read-default-tsconfig'
 
-const DEFAULT_EXTENSIONS = ['.js', '.jsx', '.es6', '.es', '.mjs', '.ts', '.tsx']
-const PLATFORM = platform()
+const DEFAULT_EXTENSIONS = [
+  ts.Extension.Js,
+  ts.Extension.Ts,
+  ts.Extension.Jsx,
+  ts.Extension.Tsx,
+  ts.Extension.Mjs,
+  ts.Extension.Mts,
+  ts.Extension.Cjs,
+  ts.Extension.Cts,
+  '.es6',
+  '.es',
+]
+
+export const AVAILABLE_TS_EXTENSION_PATTERN = new RegExp(
+  `(?<!\\.d(${[ts.Extension.Ts, ts.Extension.Tsx, ts.Extension.Mts, ts.Extension.Cts].map((ext) => ext.replace(/^\./, '\\.')).join('|')}))$`,
+  'i',
+)
+
+export const AVAILABLE_EXTENSION_PATTERN = new RegExp(
+  `(?<!\\.d(${DEFAULT_EXTENSIONS.map((ext) => ext.replace(/^\./, '\\.')).join('|')}))$`,
+  'i',
+)
 
 const injectInlineSourceMap = ({
   filename,
@@ -32,49 +49,51 @@ const injectInlineSourceMap = ({
 export function compile(
   sourcecode: string,
   filename: string,
-  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },
+  options: ts.CompilerOptions & {
+    fallbackToTs?: (filename: string) => boolean
+  },
 ): string
 
 export function compile(
   sourcecode: string,
   filename: string,
-  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },
+  options: ts.CompilerOptions & {
+    fallbackToTs?: (filename: string) => boolean
+  },
   async: false,
 ): string
 
 export function compile(
   sourcecode: string,
   filename: string,
-  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },
+  options: ts.CompilerOptions & {
+    fallbackToTs?: (filename: string) => boolean
+  },
   async: true,
 ): Promise<string>
 
 export function compile(
   sourcecode: string,
   filename: string,
-  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },
+  options: ts.CompilerOptions & {
+    fallbackToTs?: (filename: string) => boolean
+  },
   async: boolean,
 ): string | Promise<string>
 
 export function compile(
   sourcecode: string,
   filename: string,
-  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },
+  options: ts.CompilerOptions & {
+    fallbackToTs?: (filename: string) => boolean
+  },
   async = false,
 ) {
-  if (filename.endsWith('.d.ts')) {
-    return ''
-  }
-  if (options.files && (options.files as string[]).length) {
-    if (
-      PLATFORM === 'win32' &&
-      (options.files as string[]).every((file) => filename !== resolve(process.cwd(), file))
-    ) {
-      return sourcecode
-    }
-    if (PLATFORM !== 'win32' && (options.files as string[]).every((file) => !filename.endsWith(file))) {
-      return sourcecode
-    }
+  if (
+    (filename.includes('node_modules') && !AVAILABLE_TS_EXTENSION_PATTERN.test(filename)) ||
+    !AVAILABLE_EXTENSION_PATTERN.test(filename)
+  ) {
+    return sourcecode
   }
   if (options && typeof options.fallbackToTs === 'function' && options.fallbackToTs(filename)) {
     delete options.fallbackToTs
@@ -96,7 +115,7 @@ export function compile(
   } else {
     swcRegisterConfig = tsCompilerOptionsToSwcConfig(options, filename)
   }
-  
+
   if (async) {
     return transform(sourcecode, filename, swcRegisterConfig).then(({ code, map }) => {
       return injectInlineSourceMap({ filename, code, map })
@@ -108,8 +127,8 @@ export function compile(
 }
 
 export function register(options: Partial<ts.CompilerOptions> = {}, hookOpts = {}) {
-  if (!process.env.SWCRC) { 
-    options = Object.keys(options).length ? options : readDefaultTsConfig() 
+  if (!process.env.SWCRC) {
+    options = Object.keys(options).length ? options : readDefaultTsConfig()
   }
   options.module = ts.ModuleKind.CommonJS
   installSourceMapSupport()

packages/register/tsconfig.json

@@ -11,5 +11,5 @@
     },
   ],
   "include": ["."],
-  "exclude": ["lib"],
+  "exclude": ["lib", "__test__"],
 }