refactor(cem): use TypeScript's resolveModuleName() for import resolution

Replace manual path resolution logic with TypeScript's built-in module
resolution API for more accurate and consistent import handling.

Changes:
- Update findTypePath() to use ts.resolveModuleName()
- Update findPathAndTypesFromImports() to use ts.resolveModuleName()
- Remove manual path construction and extension conversion logic
- Remove unused ROOT_DIR constant
- Pass ts instance and module file path to resolution functions

This ensures the plugin follows the same module resolution rules as
TypeScript itself, handling edge cases like .d.ts files and index
files automatically.

Author: Galimede

cem/support-typedef-jsdoc-utils.js

@@ -136,18 +136,27 @@ function isVarInitWithDoc(node, ts, gatherPrivate = false) {
   return isVarInit && hasJsDoc && hasTypeIdentifier && (!isFieldPrivate || gatherPrivate);
 }
 
-export function findTypePath(importTag, rootDir, moduleDir) {
+export function findTypePath(importTag, ts, moduleFilePath) {
   // Remove leading and ending quotes
   const typeRelativePath = importTag.typeExpression?.type?.argument?.literal.getText().slice(1, -1);
 
   if (typeRelativePath == null) {
     return null;
   }
 
-  const { dir: typeDir, name: typeFileName } = path.parse(typeRelativePath);
-  const typeToTs = convertToTSExt(typeFileName);
+  // Use TypeScript's module resolution
+  const compilerOptions = {
+    moduleResolution: ts.ModuleResolutionKind.NodeJs,
+    allowJs: true,
+  };
 
-  return path.resolve(rootDir, moduleDir, typeDir, typeToTs);
+  const result = ts.resolveModuleName(typeRelativePath, moduleFilePath, compilerOptions, ts.sys);
+
+  if (result.resolvedModule) {
+    return result.resolvedModule.resolvedFileName;
+  }
+
+  return null;
 }
 
 export function findSubtypes(ts, node, types, parents) {
@@ -275,28 +284,31 @@ export function findPathAndTypesFromImports(ts, filePath, ancestors = null) {
   const imports = [];
   let sourceCode = '';
 
-  const parsedPath = path.parse(filePath);
-  const formattedFilePath = path.resolve(parsedPath.dir, convertToTSExt(filePath));
-
-  const currentAncestors = ancestors == null ? [formattedFilePath] : ancestors;
+  const currentAncestors = ancestors == null ? [filePath] : ancestors;
 
   // Open file
   try {
-    sourceCode = readFileSync(formattedFilePath).toString();
+    sourceCode = readFileSync(filePath).toString();
   } catch (e) {
     console.error(e);
     return [];
   }
 
   // transform to AST
-  const sourceAst = ts.createSourceFile(formattedFilePath, sourceCode, ts.ScriptTarget.ES2015, true);
+  const sourceAst = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.ES2015, true);
 
   // Gather only imports from the AST
   const importsDeclaration = sourceAst.statements.filter((node) => node.kind === ts.SyntaxKind.ImportDeclaration);
   if (importsDeclaration == null) {
     return [];
   }
 
+  // Use TypeScript's module resolution
+  const compilerOptions = {
+    moduleResolution: ts.ModuleResolutionKind.NodeJs,
+    allowJs: true,
+  };
+
   importsDeclaration.forEach((importNode) => {
     const types = [];
     const importFile = importNode.moduleSpecifier.text;
@@ -305,14 +317,18 @@ export function findPathAndTypesFromImports(ts, filePath, ancestors = null) {
       return;
     }
 
-    const parsedImportPath = path.parse(importFile);
+    const result = ts.resolveModuleName(importFile, filePath, compilerOptions, ts.sys);
+
+    if (!result.resolvedModule) {
+      return;
+    }
 
-    const formattedImportPath = path.join(parsedPath.dir, parsedImportPath.dir, convertToTSExt(parsedImportPath.base));
+    const resolvedPath = result.resolvedModule.resolvedFileName;
 
-    if (!currentAncestors.includes(formattedImportPath)) {
+    if (!currentAncestors.includes(resolvedPath)) {
       importNode.importClause.namedBindings.elements.forEach((nodeType) => types.push(nodeType.getText()));
-      imports.push({ types, path: formattedImportPath });
-      imports.push(...findPathAndTypesFromImports(ts, formattedImportPath, [...currentAncestors, formattedImportPath]));
+      imports.push({ types, path: resolvedPath });
+      imports.push(...findPathAndTypesFromImports(ts, resolvedPath, [...currentAncestors, resolvedPath]));
     }
   });
   return imports;

cem/support-typedef-jsdoc.js

@@ -1,5 +1,4 @@
 import { readFileSync } from 'fs';
-import path from 'path';
 import ts from 'typescript';
 import {
   convertInterface,
@@ -10,8 +9,6 @@ import {
   getTypesFromClass,
 } from './support-typedef-jsdoc-utils.js';
 
-const ROOT_DIR = process.cwd();
-
 export default function supportTypedefJsdoc() {
   // Map that contains a `type-path` as a key and has its markdown interface as a value.
   const typesStore = new Map();
@@ -141,12 +138,10 @@ export default function supportTypedefJsdoc() {
           statement.tags?.find((tag) => tag.kind === ts.SyntaxKind.JSDocTypedefTag),
         )?.[0];
 
-        const moduleDir = path.parse(moduleDoc.path).dir;
-
         // Check the jsDoc of the class and find the imports
         typeDefNode?.tags?.forEach((tag) => {
           // Extract the path from the @typedef import
-          const typePath = findTypePath(tag, ROOT_DIR, moduleDir);
+          const typePath = findTypePath(tag, ts, moduleDoc.path);
 
           // If an import is not correct, warn the plugin user.
           if (typePath == null) {