resolve TypeScript path aliases from tsconfig.json

Author: DenysKuchma

lib/utils/typescript.js

@@ -1,5 +1,6 @@
 import fs from 'fs'
 import path from 'path'
+import { loadConfig, createMatchPath } from 'tsconfig-paths'
 
 /**
  * Transpile TypeScript files to ES modules with CommonJS shim support
@@ -107,6 +108,53 @@ const __dirname = __dirname_fn(__filename);
   // Create a map to track transpiled files
   const transpiledFiles = new Map()
   const baseDir = path.dirname(mainFilePath)
+  const pathsMatcher = loadTsConfigPaths(baseDir)
+
+  /**
+   * Load tsconfig.json and create path matcher for resolving aliases
+   */
+  function loadTsConfigPaths(startDir) {
+    try {
+      let currentDir = startDir
+      let configPath = null
+      while (currentDir && currentDir !== path.parse(currentDir).root) {
+        const testPath = path.join(currentDir, 'tsconfig.json')
+        if (fs.existsSync(testPath)) {
+          configPath = testPath
+          break
+        }
+        currentDir = path.dirname(currentDir)
+      }
+
+      if (!configPath) return null
+
+      const configResult = loadConfig(configPath)
+
+      if (configResult.resultType !== 'success') return null
+
+      const { paths, absoluteBaseUrl } = configResult
+      if (!paths) return null
+
+      const matchPath = createMatchPath(
+        absoluteBaseUrl,
+        paths,
+        undefined,
+        false
+      )
+
+      return {
+        matchPath: (importPath) => {
+          for (const ext of ['.ts', '.tsx', '.js', '.jsx', '.json', '']) {
+            const resolved = matchPath(importPath + ext)
+            if (resolved) return resolved
+          }
+          return null
+        }
+      }
+    } catch (error) {
+      return null
+    }
+  }
 
   // Recursive function to transpile a file and all its TypeScript dependencies
   const transpileFileAndDeps = (filePath) => {
@@ -118,8 +166,7 @@ const __dirname = __dirname_fn(__filename);
     // Transpile this file
     let jsContent = transpileTS(filePath)
 
-    // Find all relative TypeScript imports in this file
-    const importRegex = /from\s+['"](\..+?)(?:\.ts)?['"]/g
+    const importRegex = /from\s+['"]([^'"]+?)['"]/g
     let match
     const imports = []
 
@@ -131,50 +178,113 @@ const __dirname = __dirname_fn(__filename);
     const fileBaseDir = path.dirname(filePath)
 
     // Recursively transpile each imported TypeScript file
-    for (const relativeImport of imports) {
-      let importedPath = path.resolve(fileBaseDir, relativeImport)
-
-      // Handle .js extensions that might actually be .ts files
-      if (importedPath.endsWith('.js')) {
-        const tsVersion = importedPath.replace(/\.js$/, '.ts')
-        if (fs.existsSync(tsVersion)) {
-          importedPath = tsVersion
-        }
+    for (const importPath of imports) {
+      if (importPath.startsWith('node:')) {
+        continue
       }
 
-      // Check for standard module extensions to determine if we should try adding .ts
-      const ext = path.extname(importedPath)
-      const standardExtensions = ['.js', '.mjs', '.cjs', '.json', '.node']
-      const hasStandardExtension = standardExtensions.includes(ext.toLowerCase())
-
-      // If it doesn't end with .ts and doesn't have a standard extension, try adding .ts
-      if (!importedPath.endsWith('.ts') && !hasStandardExtension) {
-        const tsPath = importedPath + '.ts'
-        if (fs.existsSync(tsPath)) {
-          importedPath = tsPath
-        } else {
-          // Try .js extension as well
-          const jsPath = importedPath + '.js'
-          if (fs.existsSync(jsPath)) {
-            // Skip .js files, they don't need transpilation
-            continue
+      if (importPath.startsWith('.')) {
+        let importedPath = path.resolve(fileBaseDir, importPath)
+
+        // Handle .js extensions that might actually be .ts files
+        if (importedPath.endsWith('.js')) {
+          const tsVersion = importedPath.replace(/\.js$/, '.ts')
+          if (fs.existsSync(tsVersion)) {
+            importedPath = tsVersion
+          }
+        }
+
+        // Check for standard module extensions to determine if we should try adding .ts
+        const ext = path.extname(importedPath)
+        const standardExtensions = ['.js', '.mjs', '.cjs', '.json', '.node']
+        const hasStandardExtension = standardExtensions.includes(ext.toLowerCase())
+
+        // If it doesn't end with .ts and doesn't have a standard extension, try adding .ts
+        if (!importedPath.endsWith('.ts') && !hasStandardExtension) {
+          const tsPath = importedPath + '.ts'
+          if (fs.existsSync(tsPath)) {
+            importedPath = tsPath
+          } else {
+            // Try .js extension as well
+            const jsPath = importedPath + '.js'
+            if (fs.existsSync(jsPath)) {
+              // Skip .js files, they don't need transpilation
+              continue
+            }
           }
         }
+
+        // If it's a TypeScript file, recursively transpile it and its dependencies
+        if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
+          transpileFileAndDeps(importedPath)
+        }
+
+        continue
       }
 
-      // If it's a TypeScript file, recursively transpile it and its dependencies
-      if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
-        transpileFileAndDeps(importedPath)
+      // Try to resolve as a path alias (non-relative import)
+      const resolvedAlias = pathsMatcher ? pathsMatcher.matchPath(importPath) : null
+      if (resolvedAlias) {
+        let importedPath = resolvedAlias
+
+        if (!importedPath.endsWith('.ts') && !path.extname(importedPath)) {
+          const tsPath = importedPath + '.ts'
+          if (fs.existsSync(tsPath)) {
+            importedPath = tsPath
+          }
+        }
+
+        if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
+          transpileFileAndDeps(importedPath)
+        }
+
+        continue
       }
     }
 
     // After all dependencies are transpiled, rewrite imports in this file
     jsContent = jsContent.replace(
-      /from\s+['"](\..+?)(?:\.ts)?['"]/g,
+      /from\s+['"]([^'"]+?)['"]/g,
       (match, importPath) => {
-        let resolvedPath = path.resolve(fileBaseDir, importPath)
         const originalExt = path.extname(importPath)
 
+        // Check if this is a path alias (non-relative import)
+        if (!importPath.startsWith('.')) {
+          const resolvedAlias = pathsMatcher ? pathsMatcher.matchPath(importPath) : null
+          if (resolvedAlias) {
+            let tsPath = resolvedAlias.endsWith('.ts') ? resolvedAlias : resolvedAlias + '.ts'
+
+            if (transpiledFiles.has(tsPath)) {
+              const tempFile = transpiledFiles.get(tsPath)
+              const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+              if (!relPath.startsWith('.')) {
+                return `from './${relPath}'`
+              }
+              return `from '${relPath}'`
+            }
+
+            if (fs.existsSync(tsPath)) {
+              const jsPath = tsPath.replace(/\.ts$/, '.js')
+              const relPath = path.relative(fileBaseDir, jsPath).replace(/\\/g, '/')
+              if (!relPath.startsWith('.')) {
+                return `from './${relPath}'`
+              }
+              return `from '${relPath}'`
+            }
+          }
+
+          const standardExtensions = ['.js', '.mjs', '.cjs', '.json', '.node']
+          const hasStandardExtension = standardExtensions.includes(originalExt.toLowerCase())
+
+          if (!hasStandardExtension && !importPath.startsWith('node:')) {
+            return match.replace(importPath, importPath + '.js')
+          }
+
+          return match
+        }
+
+        let resolvedPath = path.resolve(fileBaseDir, importPath)
+
         // Handle .js extension that might be .ts
         if (resolvedPath.endsWith('.js')) {
           const tsVersion = resolvedPath.replace(/\.js$/, '.ts')

package.json

@@ -181,6 +181,7 @@
     "sinon-chai": "^4.0.1",
     "ts-morph": "27.0.2",
     "ts-node": "10.9.2",
+    "tsconfig-paths": "^4.2.0",
     "tsd": "^0.33.0",
     "tsd-jsdoc": "2.5.0",
     "tsx": "^4.19.2",