@beignet/cli 0.0.48 → 0.0.50

package/src/analysis/source-index.ts

@@ -27,12 +27,19 @@ export type LocalImportReference = {
   column: number;
 };
 
+export type ModuleReference = LocalImportReference & {
+  syntax: "dynamic-import" | "export" | "import" | "import-equals" | "require";
+  staticallyResolvable: boolean;
+};
+
 type ImportBinding =
   | { kind: "named"; file: string; exportName: string }
   | { kind: "namespace"; file: string };
 
 type FileIndex = {
   declarations: Map<string, ts.Declaration>;
+  localExports: Map<string, string>;
+  locals: Map<string, ts.Declaration>;
   imports: Map<string, ImportBinding>;
   reexports: Map<string, { file: string; exportName: string }>;
   exportStars: string[];
@@ -68,6 +75,8 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
     const sourceFile = await workspace.readSourceFile(file);
     const index: FileIndex = {
       declarations: new Map(),
+      localExports: new Map(),
+      locals: new Map(),
       imports: new Map(),
       reexports: new Map(),
       exportStars: [],
@@ -115,6 +124,22 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
         const target = source
           ? resolveLocalSourceFile(workspace, file, source)
           : undefined;
+
+        if (!statement.moduleSpecifier) {
+          if (
+            statement.exportClause &&
+            ts.isNamedExports(statement.exportClause)
+          ) {
+            for (const element of statement.exportClause.elements) {
+              if (statement.isTypeOnly || element.isTypeOnly) continue;
+              index.localExports.set(
+                element.name.text,
+                element.propertyName?.text ?? element.name.text,
+              );
+            }
+          }
+          continue;
+        }
         if (!target) continue;
 
         if (!statement.exportClause) {
@@ -133,10 +158,13 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
         continue;
       }
 
-      if (ts.isVariableStatement(statement) && hasExportModifier(statement)) {
+      if (ts.isVariableStatement(statement)) {
         for (const declaration of statement.declarationList.declarations) {
           if (ts.isIdentifier(declaration.name)) {
-            index.declarations.set(declaration.name.text, declaration);
+            index.locals.set(declaration.name.text, declaration);
+            if (hasExportModifier(statement)) {
+              index.declarations.set(declaration.name.text, declaration);
+            }
           }
         }
         continue;
@@ -148,10 +176,12 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
           ts.isInterfaceDeclaration(statement) ||
           ts.isTypeAliasDeclaration(statement) ||
           ts.isEnumDeclaration(statement)) &&
-        hasExportModifier(statement) &&
         statement.name
       ) {
-        index.declarations.set(statement.name.text, statement);
+        index.locals.set(statement.name.text, statement);
+        if (hasExportModifier(statement)) {
+          index.declarations.set(statement.name.text, statement);
+        }
       }
     }
 
@@ -171,6 +201,14 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
     const declaration = index.declarations.get(exportName);
     if (declaration) return { file, exportName, declaration };
 
+    const localName = index.localExports.get(exportName);
+    const localDeclaration = localName
+      ? index.locals.get(localName)
+      : undefined;
+    if (localDeclaration) {
+      return { file, exportName, declaration: localDeclaration };
+    }
+
     const reexport = index.reexports.get(exportName);
     if (reexport) {
       return (
@@ -192,7 +230,7 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
   return {
     async resolveName(file, name) {
       const index = await readIndex(file);
-      const local = index.declarations.get(name);
+      const local = index.locals.get(name);
       if (local) {
         return { file, exportName: name, declaration: local };
       }
@@ -267,20 +305,48 @@ export function exportedVariableDeclarations(
     declaration: ts.VariableDeclaration;
   }> = [];
 
+  const locals = new Map<string, ts.VariableDeclaration>();
+  const seen = new Set<string>();
+  const addDeclaration = (
+    exportName: string,
+    declaration: ts.VariableDeclaration,
+  ) => {
+    const key = `${exportName}:${declaration.pos}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    declarations.push({ exportName, declaration });
+  };
+
   for (const statement of sourceFile.statements) {
-    if (!ts.isVariableStatement(statement) || !hasExportModifier(statement)) {
-      continue;
-    }
+    if (!ts.isVariableStatement(statement)) continue;
     for (const declaration of statement.declarationList.declarations) {
       if (ts.isIdentifier(declaration.name)) {
-        declarations.push({
-          exportName: declaration.name.text,
-          declaration,
-        });
+        locals.set(declaration.name.text, declaration);
+        if (hasExportModifier(statement)) {
+          addDeclaration(declaration.name.text, declaration);
+        }
       }
     }
   }
 
+  for (const statement of sourceFile.statements) {
+    if (
+      !ts.isExportDeclaration(statement) ||
+      statement.moduleSpecifier ||
+      statement.isTypeOnly ||
+      !statement.exportClause ||
+      !ts.isNamedExports(statement.exportClause)
+    ) {
+      continue;
+    }
+    for (const element of statement.exportClause.elements) {
+      if (element.isTypeOnly) continue;
+      const localName = element.propertyName?.text ?? element.name.text;
+      const declaration = locals.get(localName);
+      if (declaration) addDeclaration(element.name.text, declaration);
+    }
+  }
+
   return declarations;
 }
 
@@ -321,64 +387,166 @@ export async function localImportReferences(
   workspace: AnalysisWorkspace,
   file: string,
 ): Promise<LocalImportReference[]> {
-  const sourceFile = await workspace.readSourceFile(file);
-  const references: LocalImportReference[] = [];
-
-  for (const statement of sourceFile.statements) {
-    if (
-      !ts.isImportDeclaration(statement) &&
-      !ts.isExportDeclaration(statement)
-    ) {
-      continue;
-    }
-    if (!statement.moduleSpecifier) continue;
-
-    const importPath = moduleText(statement.moduleSpecifier);
-    const resolvedFile = importPath
-      ? resolveLocalSourceFile(workspace, file, importPath)
-      : undefined;
-    if (
-      !importPath ||
-      (!resolvedFile && !isLocalModuleSpecifier(workspace, file, importPath))
-    ) {
-      continue;
-    }
+  const references = await moduleReferences(workspace, file);
+
+  return references
+    .filter(
+      (reference) =>
+        reference.staticallyResolvable &&
+        (reference.resolvedFile ||
+          isLocalModuleSpecifier(workspace, file, reference.importPath)),
+    )
+    .map(
+      ({ syntax: _syntax, staticallyResolvable: _static, ...reference }) =>
+        reference,
+    );
+}
 
+export async function moduleReferences(
+  workspace: AnalysisWorkspace,
+  file: string,
+): Promise<ModuleReference[]> {
+  const sourceFile = await workspace.readSourceFile(file);
+  const references: ModuleReference[] = [];
+
+  const addReference = ({
+    importPath,
+    kind,
+    node,
+    staticallyResolvable,
+    syntax,
+  }: {
+    importPath: string;
+    kind: "type" | "value";
+    node: ts.Node;
+    staticallyResolvable: boolean;
+    syntax: ModuleReference["syntax"];
+  }) => {
     const position = sourceFile.getLineAndCharacterOfPosition(
-      statement.getStart(sourceFile),
+      node.getStart(sourceFile),
     );
-    const typeOnly = ts.isImportDeclaration(statement)
-      ? Boolean(
-          statement.importClause?.isTypeOnly ||
-            (statement.importClause?.namedBindings &&
-              ts.isNamedImports(statement.importClause.namedBindings) &&
-              statement.importClause.namedBindings.elements.length > 0 &&
-              statement.importClause.namedBindings.elements.every(
-                (element) => element.isTypeOnly,
-              )),
-        )
-      : statement.isTypeOnly ||
-        (statement.exportClause &&
-          ts.isNamedExports(statement.exportClause) &&
-          statement.exportClause.elements.length > 0 &&
-          statement.exportClause.elements.every(
-            (element) => element.isTypeOnly,
-          ));
     references.push({
       file,
       importPath,
-      resolvedFile,
-      kind: typeOnly ? "type" : "value",
+      ...(staticallyResolvable
+        ? { resolvedFile: resolveLocalSourceFile(workspace, file, importPath) }
+        : {}),
+      kind,
       line: position.line + 1,
       column: position.character + 1,
+      syntax,
+      staticallyResolvable,
     });
-  }
+  };
+
+  const visit = (node: ts.Node) => {
+    if (ts.isImportDeclaration(node) && node.moduleSpecifier) {
+      const importPath = moduleText(node.moduleSpecifier);
+      if (importPath) {
+        addReference({
+          importPath,
+          kind: importDeclarationKind(node),
+          node,
+          staticallyResolvable: true,
+          syntax: "import",
+        });
+      }
+    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+      const importPath = moduleText(node.moduleSpecifier);
+      if (importPath) {
+        addReference({
+          importPath,
+          kind: exportDeclarationKind(node),
+          node,
+          staticallyResolvable: true,
+          syntax: "export",
+        });
+      }
+    } else if (
+      ts.isImportEqualsDeclaration(node) &&
+      ts.isExternalModuleReference(node.moduleReference) &&
+      node.moduleReference.expression
+    ) {
+      const importPath = moduleText(node.moduleReference.expression);
+      if (importPath) {
+        addReference({
+          importPath,
+          kind: node.isTypeOnly ? "type" : "value",
+          node,
+          staticallyResolvable: true,
+          syntax: "import-equals",
+        });
+      }
+    } else if (ts.isCallExpression(node)) {
+      const syntax =
+        node.expression.kind === ts.SyntaxKind.ImportKeyword
+          ? "dynamic-import"
+          : ts.isIdentifier(node.expression) &&
+              node.expression.text === "require"
+            ? "require"
+            : undefined;
+      if (syntax) {
+        const argument = node.arguments[0];
+        const importPath = moduleText(argument);
+        addReference({
+          importPath:
+            importPath ?? argument?.getText(sourceFile) ?? "<missing>",
+          kind: "value",
+          node,
+          staticallyResolvable: importPath !== undefined,
+          syntax,
+        });
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
 
   return references;
 }
 
-function moduleText(node: ts.Expression): string | undefined {
-  return ts.isStringLiteral(node) ? node.text : undefined;
+function importDeclarationKind(
+  declaration: ts.ImportDeclaration,
+): "type" | "value" {
+  const clause = declaration.importClause;
+  if (!clause) return "value";
+  if (clause.isTypeOnly) return "type";
+  if (clause.name) return "value";
+
+  const bindings = clause.namedBindings;
+  if (
+    bindings &&
+    ts.isNamedImports(bindings) &&
+    bindings.elements.length > 0 &&
+    bindings.elements.every((element) => element.isTypeOnly)
+  ) {
+    return "type";
+  }
+  return "value";
+}
+
+function exportDeclarationKind(
+  declaration: ts.ExportDeclaration,
+): "type" | "value" {
+  if (declaration.isTypeOnly) return "type";
+  if (
+    declaration.exportClause &&
+    ts.isNamedExports(declaration.exportClause) &&
+    declaration.exportClause.elements.length > 0 &&
+    declaration.exportClause.elements.every((element) => element.isTypeOnly)
+  ) {
+    return "type";
+  }
+  return "value";
+}
+
+function moduleText(node: ts.Expression | undefined): string | undefined {
+  return node &&
+    (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+    ? node.text
+    : undefined;
 }
 
 function hasExportModifier(node: ts.Node): boolean {

package/src/analysis/workspace.ts

@@ -2,9 +2,11 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
 import {
+  type BeignetConfig,
   loadBeignetConfig,
   normalizePath,
   type ResolvedBeignetConfig,
+  resolveConfig,
 } from "../config.js";
 
 const ignoredDirectoryNames = new Set([
@@ -22,19 +24,36 @@ export type AnalysisWorkspace = {
   fileSet: Set<string>;
   config: ResolvedBeignetConfig;
   compilerOptions: ts.CompilerOptions;
+  compilerConfigFiles: string[];
+  moduleResolutionCache: ts.ModuleResolutionCache;
   readSource(file: string): Promise<string>;
   readSourceFile(file: string): Promise<ts.SourceFile>;
 };
 
+type AnalysisWorkspaceOptions = {
+  config?: BeignetConfig;
+};
+
 export async function createAnalysisWorkspace(
   cwd = process.cwd(),
+  options: AnalysisWorkspaceOptions = {},
 ): Promise<AnalysisWorkspace> {
   const targetDir = path.resolve(cwd);
   await assertDirectory(targetDir);
   const files = await listProjectFiles(targetDir);
   const fileSet = new Set(files);
-  const config = await loadBeignetConfig(targetDir, files);
-  const compilerOptions = resolveCompilerOptions(targetDir);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir, files);
+  const { compilerConfigFiles, compilerOptions } =
+    resolveCompilerConfiguration(targetDir);
+  const moduleResolutionCache = ts.createModuleResolutionCache(
+    targetDir,
+    ts.sys.useCaseSensitiveFileNames
+      ? (fileName) => fileName
+      : (fileName) => fileName.toLowerCase(),
+    compilerOptions,
+  );
   const sources = new Map<string, string>();
   const sourceFiles = new Map<string, ts.SourceFile>();
 
@@ -53,6 +72,8 @@ export async function createAnalysisWorkspace(
     fileSet,
     config,
     compilerOptions,
+    compilerConfigFiles,
+    moduleResolutionCache,
     readSource,
     async readSourceFile(file) {
       const cached = sourceFiles.get(file);
@@ -111,7 +132,7 @@ export async function listProjectFiles(targetDir: string): Promise<string[]> {
 export function resolveLocalSourceFile(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "fileSet" | "targetDir"
+    "compilerOptions" | "fileSet" | "moduleResolutionCache" | "targetDir"
   >,
   importerFile: string,
   importPath: string,
@@ -126,10 +147,62 @@ export function resolveLocalSourceFile(
   return workspace.fileSet.has(file) ? file : undefined;
 }
 
+export function resolveLocalModulePath(
+  workspace: Pick<
+    AnalysisWorkspace,
+    "compilerOptions" | "fileSet" | "moduleResolutionCache" | "targetDir"
+  >,
+  importerFile: string,
+  importPath: string,
+): string | undefined {
+  const resolvedFile = resolveLocalSourceFile(
+    workspace,
+    importerFile,
+    importPath,
+  );
+  if (resolvedFile) return resolvedFile;
+
+  if (!isLocalModuleSpecifier(workspace, importerFile, importPath)) {
+    return undefined;
+  }
+
+  if (importPath.startsWith(".")) {
+    return normalizePath(path.join(path.dirname(importerFile), importPath));
+  }
+
+  const baseUrl = compilerPathsBase(
+    workspace.compilerOptions,
+    workspace.targetDir,
+  );
+  for (const [pattern, targets] of Object.entries(
+    workspace.compilerOptions.paths ?? {},
+  )) {
+    if (pattern === "*") continue;
+    const wildcardValue = modulePatternWildcard(pattern, importPath);
+    if (wildcardValue === undefined) continue;
+
+    for (const target of targets) {
+      const substituted = target.replace("*", wildcardValue);
+      const absolute = path.resolve(baseUrl, substituted);
+      const relative = normalizePath(
+        path.relative(workspace.targetDir, absolute),
+      );
+      if (relative !== ".." && !relative.startsWith("../")) return relative;
+    }
+  }
+
+  const relative = normalizePath(
+    path.relative(workspace.targetDir, path.resolve(baseUrl, importPath)),
+  );
+  return relative !== ".." && !relative.startsWith("../")
+    ? relative
+    : undefined;
+}
+
 export function isLocalModuleSpecifier(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "fileSet" | "targetDir"
+    "compilerOptions" | "fileSet" | "moduleResolutionCache" | "targetDir"
   >,
   importerFile: string,
   importPath: string,
@@ -180,7 +253,10 @@ export function isLocalModuleSpecifier(
 }
 
 function resolveModule(
-  workspace: Pick<AnalysisWorkspace, "compilerOptions" | "targetDir">,
+  workspace: Pick<
+    AnalysisWorkspace,
+    "compilerOptions" | "moduleResolutionCache" | "targetDir"
+  >,
   importerFile: string,
   importPath: string,
 ): ts.ResolvedModuleFull | undefined {
@@ -189,6 +265,7 @@ function resolveModule(
     path.join(workspace.targetDir, importerFile),
     workspace.compilerOptions,
     ts.sys,
+    workspace.moduleResolutionCache,
   ).resolvedModule;
 }
 
@@ -201,16 +278,64 @@ function modulePatternMatches(pattern: string, importPath: string): boolean {
   );
 }
 
-function resolveCompilerOptions(targetDir: string): ts.CompilerOptions {
-  return (
+function modulePatternWildcard(
+  pattern: string,
+  importPath: string,
+): string | undefined {
+  const wildcard = pattern.indexOf("*");
+  if (wildcard === -1) return pattern === importPath ? "" : undefined;
+
+  const prefix = pattern.slice(0, wildcard);
+  const suffix = pattern.slice(wildcard + 1);
+  if (!importPath.startsWith(prefix) || !importPath.endsWith(suffix)) {
+    return undefined;
+  }
+  return importPath.slice(prefix.length, importPath.length - suffix.length);
+}
+
+function resolveCompilerConfiguration(targetDir: string): {
+  compilerConfigFiles: string[];
+  compilerOptions: ts.CompilerOptions;
+} {
+  const compilerConfigFiles = new Set<string>();
+  const configPath = path.join(targetDir, "tsconfig.json");
+  const compilerOptions =
     ts.getParsedCommandLineOfConfigFile(
-      path.join(targetDir, "tsconfig.json"),
+      configPath,
       {},
       {
         ...ts.sys,
+        readFile(file) {
+          compilerConfigFiles.add(path.resolve(file));
+          return ts.sys.readFile(file);
+        },
         onUnRecoverableConfigFileDiagnostic: () => {},
       },
-    )?.options ?? {}
+    )?.options ?? {};
+
+  return {
+    compilerConfigFiles: [...compilerConfigFiles].sort(),
+    compilerOptions: compilerOptions.paths
+      ? compilerOptions
+      : {
+          ...compilerOptions,
+          baseUrl: compilerOptions.baseUrl ?? targetDir,
+          paths: {
+            "@/*": ["*"],
+          },
+        },
+  };
+}
+
+function compilerPathsBase(
+  compilerOptions: ts.CompilerOptions,
+  targetDir: string,
+): string {
+  const optionsWithPathBase = compilerOptions as ts.CompilerOptions & {
+    pathsBasePath?: string;
+  };
+  return (
+    compilerOptions.baseUrl ?? optionsWithPathBase.pathsBasePath ?? targetDir
   );
 }