feat: use @rollup/plugin-typescript to resolve id (#22)

Author: hanayashiki

.github/workflows/release.yml

@@ -25,3 +25,4 @@ jobs:
       - run: npx conventional-github-releaser -p angular
         env:
           CONVENTIONAL_GITHUB_RELEASER_TOKEN: ${{secrets.GITHUB_TOKEN}}
+

loader.mjs

@@ -1,20 +1,17 @@
 import { URL, pathToFileURL, fileURLToPath } from 'url'
 import fs from 'fs'
+import path from 'path'
 import { transformSync } from 'esbuild'
-import { createMatchPath, loadConfig } from 'tsconfig-paths'
+import typescript from '@rollup/plugin-typescript'
+import JoyCon from 'joycon'
 
-const baseURL = pathToFileURL(`${process.cwd()}/`).href
 const isWindows = process.platform === 'win32'
 
 const extensionsRegex = /\.(m?tsx?|json)$/
-const excludeRegex = /^\w+:/
-const tsExtensions = ['.mts', '.ts', '.cts', '.tsx'] // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html
-const jsExtensions = ['.mjs', '.js', '.cjs', '.jsx']
-const extensions = [...tsExtensions, ...jsExtensions]
-
-const tsconfig = loadConfig()
-
-const matchPath = tsconfig.resultType === 'success' ? createMatchPath(tsconfig.absoluteBaseUrl, tsconfig.paths) : undefined
+const tsconfigPath = new JoyCon({ parseJSON: () => {} }).loadSync(['tsconfig.json']).path
+const pluginTypescript = typescript({
+  tsconfig: tsconfigPath,
+})
 
 function esbuildTransformSync(rawSource, filename, url, format) {
   const {
@@ -39,49 +36,75 @@ function esbuildTransformSync(rawSource, filename, url, format) {
   return { js, jsSourceMap }
 }
 
-export const tryPathWithExtensions = (path) => {
-  for (const ext of extensions) {
-    const p = `${path}${ext}`
-    if (fs.existsSync(p))
-      return p
+function getTsCompatSpecifier(parentURL, specifier) {
+  let tsSpecifier
+  let search
+
+  if (specifier.startsWith('./') || specifier.startsWith('../')) {
+    // Relative import
+    const url = new URL(specifier, parentURL)
+    tsSpecifier = fileURLToPath(url).replace(/\.tsx?$/, '')
+    search = url.search
+  }
+  else {
+    // Bare import
+    tsSpecifier = specifier
+    search = ''
+  }
+
+  return {
+    tsSpecifier,
+    search,
   }
-  return null
 }
 
-export function resolve(specifier, context, defaultResolve) {
-  // baseUrl & paths takes the highest precedence, as TypeScript behaves.
-  if (matchPath) {
-    const nodePath = matchPath(specifier, undefined, undefined, extensions)
+function isValidURL(s) {
+  try {
+    return !!new URL(s)
+  }
+  catch (e) {
+    if (e instanceof TypeError)
+      return false
 
-    if (nodePath) {
-      const foundPath = tryPathWithExtensions(nodePath)
-      return {
-        url: pathToFileURL(foundPath).href,
-        format: extensionsRegex.test(foundPath) && 'module',
-      }
+    throw e
+  }
+}
+
+export async function resolve(specifier, context, defaultResolve) {
+  const {
+    parentURL,
+  } = context
+
+  let url
+
+  // According to Node's algorithm, we first check if it is a valid URL.
+  // When the module is the entry point, node will provides a file URL to it.
+  if (isValidURL(specifier)) {
+    url = new URL(specifier)
+  }
+  else {
+    // Try to resolve the module according to typescript's algorithm,
+    // and construct a valid url.
+    const parsed = getTsCompatSpecifier(parentURL, specifier)
+    const path = pluginTypescript.resolveId(parsed.tsSpecifier, fileURLToPath(parentURL))
+    if (path) {
+      url = pathToFileURL(path)
+      url.search = parsed.search
     }
   }
 
-  const { parentURL = baseURL } = context
-  const url = new URL(specifier, parentURL)
-  if (extensionsRegex.test(url.pathname))
-    return { url: url.href, format: 'module' }
-
-  // ignore `data:` and `node:` prefix etc.
-  if (!excludeRegex.test(specifier)) {
-    // Try to resolve extension
-    const path = fileURLToPath(url.href)
-    const foundPath = tryPathWithExtensions(path)
-    if (foundPath) {
-      url.pathname = foundPath
+  if (url) {
+    // If the resolved file is typescript
+    if (extensionsRegex.test(url.pathname)) {
       return {
         url: url.href,
-        format: extensionsRegex.test(url.pathname) && 'module',
+        format: 'module',
       }
     }
+    // Else, for other types, use default resolve with the valid path
+    return defaultResolve(url.href, context, defaultResolve)
   }
 
-  // Let Node.js handle all other specifiers.
   return defaultResolve(specifier, context, defaultResolve)
 }
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "esbuild-node-loader",
-  "version": "0.5.0",
+  "version": "0.4.3",
   "description": "Transpile TypeScript to ESM with Node.js loader",
   "keywords": [
     "node-loader"
@@ -33,8 +33,9 @@
     "test": "node --experimental-loader ./loader.mjs test/entry.ts"
   },
   "dependencies": {
+    "@rollup/plugin-typescript": "^8.3.0",
     "esbuild": "^0.13.3",
-    "tsconfig-paths": "^3.11.0"
+    "joycon": "^3.0.1"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^0.9.0",

pnpm-lock.yaml

@@ -66,9 +66,9 @@ test('import type module', async() => {
   const { stdout } = await execa('node', [
     '--experimental-loader',
     relativize(`${cwd}/loader.mjs`),
-    relativize(`${cwd}/test/import-mjs/index.js`),
+    relativize(`${cwd}/test/import-mjs/index.ts`),
   ])
-  assert(stdout === 'foo')
+  assert(stdout === 'foo\nnot index\nexport')
 })
 
 test('import with query', async() => {
@@ -108,7 +108,7 @@ test('import json', async() => {
 })
 
 test('tsconfig-paths', async() => {
-  const cwd2 = `${cwd}/test/tsconfig-paths`;
+  const cwd2 = `${cwd}/test/tsconfig-paths`
   const { stdout } = await execa('node', [
     '--experimental-loader',
     relativize(`${cwd}/loader.mjs`, cwd2),

test/entry.ts

@@ -0,0 +1,8 @@
+import foo from 'foo'
+import notIndex from 'foo/not-index'
+import notIndex from 'foo/not-index.js'
+import { a } from '../fixture.export'
+
+console.log(foo)
+console.log(notIndex)
+console.log(a)