@beignet/cli 0.0.51 → 0.0.53

package/src/analysis/port-wiring.ts

@@ -2,7 +2,16 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
 import type { ResolvedBeignetConfig } from "../config.js";
-import type { AnalysisWorkspace } from "./workspace.js";
+import { sourceFileScriptKind } from "./source-files.js";
+import {
+  createSourceIndex,
+  type ResolvedSourceReference,
+  type SourceIndex,
+} from "./source-index.js";
+import {
+  type AnalysisWorkspace,
+  createAnalysisWorkspace,
+} from "./workspace.js";
 
 type PortAnalysisWorkspace = Pick<
   AnalysisWorkspace,
@@ -13,6 +22,7 @@ export type PortWiringAnalysis = {
   portsFileExists: boolean;
   portWiringFileExists: boolean;
   properties: Map<string, ts.PropertySignature>;
+  propertyFiles: Map<string, string>;
   declared: Set<string>;
   bound: Set<string>;
   deferred: Set<string>;
@@ -23,6 +33,7 @@ export type PortWiringAnalysis = {
 
 export async function analyzePortWiring(
   workspace: PortAnalysisWorkspace,
+  sourceIndex?: SourceIndex,
 ): Promise<PortWiringAnalysis> {
   const result: PortWiringAnalysis = {
     portsFileExists: workspace.fileSet.has(workspace.config.paths.ports),
@@ -30,6 +41,7 @@ export async function analyzePortWiring(
       workspace.config.paths.portWiring,
     ),
     properties: new Map(),
+    propertyFiles: new Map(),
     declared: new Set(),
     bound: new Set(),
     deferred: new Set(),
@@ -39,20 +51,31 @@ export async function analyzePortWiring(
   };
 
   let inferredAppPortsName: string | undefined;
+  let inferredAppPortsReference: ResolvedSourceReference | undefined;
   if (result.portsFileExists) {
-    const sourceFile = await workspace.readSourceFile(
+    const reference = await sourceIndex?.resolveExport(
       workspace.config.paths.ports,
+      "AppPorts",
     );
+    const portsFile = reference?.file ?? workspace.config.paths.ports;
+    const portsName = reference?.exportName ?? "AppPorts";
+    const sourceFile = await workspace.readSourceFile(portsFile);
     const declarations = collectTypeDeclarations(sourceFile);
-    inferredAppPortsName = inferredTypeQueryName("AppPorts", declarations);
+    inferredAppPortsName = inferredTypeQueryName(portsName, declarations);
+    if (inferredAppPortsName)
+      inferredAppPortsReference = await sourceIndex?.resolveName(
+        portsFile,
+        inferredAppPortsName,
+      );
     const collection = inferredAppPortsName
       ? { properties: [], indeterminate: false }
-      : collectNamedTypeProperties("AppPorts", declarations, true);
+      : collectNamedTypeProperties(portsName, declarations, !sourceIndex);
     result.declarationIndeterminate = collection.indeterminate;
     for (const property of collection.properties) {
       const name = propertyName(property.name);
       if (name && !result.properties.has(name)) {
         result.properties.set(name, property);
+        result.propertyFiles.set(name, portsFile);
         result.declared.add(name);
       }
     }
@@ -62,12 +85,27 @@ export async function analyzePortWiring(
     if (inferredAppPortsName) result.declarationIndeterminate = true;
     return result;
   }
-  const sourceFile = await workspace.readSourceFile(
+  const wiringReference = await sourceIndex?.resolveExport(
     workspace.config.paths.portWiring,
+    "initialPorts",
+  );
+  const sourceFile = await workspace.readSourceFile(
+    wiringReference?.file ?? workspace.config.paths.portWiring,
   );
   const values = collectVariableInitializers(sourceFile);
-  const definitions = portDefinitionCalls(sourceFile);
-  if (definitions.indeterminate) result.indeterminate = true;
+  const definitions = portDefinitionCalls(
+    sourceFile,
+    wiringReference?.declaration &&
+      ts.isVariableDeclaration(wiringReference.declaration) &&
+      ts.isIdentifier(wiringReference.declaration.name)
+      ? wiringReference.declaration.name.text
+      : wiringReference?.exportName,
+  );
+  if (
+    definitions.indeterminate ||
+    (sourceIndex && definitions.calls.length === 0)
+  )
+    result.indeterminate = true;
 
   for (const call of definitions.calls) {
     const objectArgument = call.arguments
@@ -123,7 +161,13 @@ export async function analyzePortWiring(
   if (inferredAppPortsName) {
     if (
       !definitions.indeterminate &&
-      definitions.name === inferredAppPortsName
+      (sourceIndex
+        ? Boolean(
+            inferredAppPortsReference?.declaration &&
+              inferredAppPortsReference.declaration ===
+                wiringReference?.declaration,
+          )
+        : definitions.name === inferredAppPortsName)
     ) {
       result.appPortsInferredFromWiring = true;
       for (const name of result.bound) result.declared.add(name);
@@ -136,7 +180,10 @@ export async function analyzePortWiring(
   return result;
 }
 
-function portDefinitionCalls(sourceFile: ts.SourceFile): {
+function portDefinitionCalls(
+  sourceFile: ts.SourceFile,
+  preferredName?: string,
+): {
   calls: ts.CallExpression[];
   name?: string;
   indeterminate: boolean;
@@ -171,8 +218,12 @@ function portDefinitionCalls(sourceFile: ts.SourceFile): {
   }
 
   const canonical = candidates.filter(
-    (candidate) => candidate.name === "initialPorts" && candidate.exported,
+    (candidate) =>
+      candidate.name === (preferredName ?? "initialPorts") &&
+      candidate.exported,
   );
+  if (preferredName && canonical.length === 0)
+    return { calls: [], indeterminate: true };
   const exported = candidates.filter((candidate) => candidate.exported);
   const selected =
     canonical.length > 0
@@ -229,6 +280,12 @@ export async function analyzePortWiringFiles(options: {
   files: readonly string[];
   config: ResolvedBeignetConfig;
 }): Promise<PortWiringAnalysis> {
+  if (options.config.workspace.packages.length > 0) {
+    const workspace = await createAnalysisWorkspace(options.targetDir, {
+      config: options.config,
+    });
+    return analyzePortWiring(workspace, createSourceIndex(workspace));
+  }
   const sourceFiles = new Map<string, ts.SourceFile>();
   return analyzePortWiring({
     config: options.config,
@@ -241,7 +298,7 @@ export async function analyzePortWiringFiles(options: {
         await readFile(path.join(options.targetDir, file), "utf8"),
         ts.ScriptTarget.Latest,
         true,
-        file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+        sourceFileScriptKind(file),
       );
       sourceFiles.set(file, sourceFile);
       return sourceFile;

package/src/analysis/source-files.ts

@@ -0,0 +1,61 @@
+import path from "node:path";
+import ts from "typescript";
+
+export const typescriptAnalysisSourceFileExtensions = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+] as const;
+
+export const javascriptAnalysisSourceFileExtensions = [
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+] as const;
+
+export const analysisSourceFileExtensions = [
+  ...typescriptAnalysisSourceFileExtensions,
+  ...javascriptAnalysisSourceFileExtensions,
+] as const;
+
+const sourceFileExtensions = new Set<string>(analysisSourceFileExtensions);
+const javascriptSourceFileExtensions = new Set<string>(
+  javascriptAnalysisSourceFileExtensions,
+);
+const declarationFilePattern = /\.d\.(?:ts|mts|cts)$/;
+
+/** Whether an extension belongs to the JavaScript/TypeScript source family. */
+export function isAnalysisSourceFileExtension(extension: string): boolean {
+  return sourceFileExtensions.has(extension);
+}
+
+/** Whether a project file can participate in Beignet source analysis. */
+export function isAnalysisSourceFile(file: string): boolean {
+  return (
+    isAnalysisSourceFileExtension(path.posix.extname(file)) &&
+    !declarationFilePattern.test(file)
+  );
+}
+
+/** Remove a JavaScript or TypeScript source extension from a path. */
+export function stripSourceFileExtension(file: string): string {
+  const extension = path.posix.extname(file);
+  return isAnalysisSourceFileExtension(extension)
+    ? file.slice(0, -extension.length)
+    : file;
+}
+
+/** Whether a source file uses JavaScript rather than TypeScript syntax. */
+export function isJavaScriptSourceFile(file: string): boolean {
+  return javascriptSourceFileExtensions.has(path.posix.extname(file));
+}
+
+/** Select the TypeScript parser mode for a JavaScript or TypeScript file. */
+export function sourceFileScriptKind(file: string): ts.ScriptKind {
+  if (file.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (file.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  if (isJavaScriptSourceFile(file)) return ts.ScriptKind.JS;
+  return ts.ScriptKind.TS;
+}

package/src/analysis/source-index.ts

@@ -53,6 +53,12 @@ export type SourceIndex = {
   resolveExpression(
     file: string,
     expression: ts.Expression,
+    locals?: ReadonlyMap<string, ts.Declaration>,
+  ): Promise<ResolvedSourceReference | undefined>;
+  resolveValue(
+    file: string,
+    expression: ts.Expression,
+    locals?: ReadonlyMap<string, ts.Declaration>,
   ): Promise<ResolvedSourceReference | undefined>;
   resolveExport(
     file: string,
@@ -131,7 +137,6 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
             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,
@@ -208,6 +213,9 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
     if (localDeclaration) {
       return { file, exportName, declaration: localDeclaration };
     }
+    const imported = localName ? index.imports.get(localName) : undefined;
+    if (imported?.kind === "named")
+      return resolveExport(imported.file, imported.exportName, visited);
 
     const reexport = index.reexports.get(exportName);
     if (reexport) {
@@ -227,7 +235,7 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
     return undefined;
   };
 
-  return {
+  const sourceIndex: SourceIndex = {
     async resolveName(file, name) {
       const index = await readIndex(file);
       const local = index.locals.get(name);
@@ -244,11 +252,12 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
         }
       );
     },
-    async resolveExpression(file, rawExpression) {
+    async resolveExpression(file, rawExpression, locals) {
       const expression = unwrapExpression(rawExpression);
       const index = await readIndex(file);
       if (ts.isIdentifier(expression)) {
-        const local = index.declarations.get(expression.text);
+        const local =
+          locals?.get(expression.text) ?? index.locals.get(expression.text);
         if (local) {
           return { file, exportName: expression.text, declaration: local };
         }
@@ -267,6 +276,11 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
         ts.isPropertyAccessExpression(expression) &&
         ts.isIdentifier(expression.expression)
       ) {
+        if (
+          locals?.has(expression.expression.text) ||
+          index.locals.has(expression.expression.text)
+        )
+          return undefined;
         const binding = index.imports.get(expression.expression.text);
         if (binding?.kind !== "namespace") return undefined;
         return (
@@ -279,6 +293,43 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
 
       return undefined;
     },
+    async resolveValue(file, expression, locals) {
+      const visited = new Set<ts.Declaration>();
+      async function follow(
+        file: string,
+        rawExpression: ts.Expression,
+        locals?: ReadonlyMap<string, ts.Declaration>,
+      ): Promise<ResolvedSourceReference | undefined> {
+        const expression = unwrapExpression(rawExpression);
+        const reference = await sourceIndex.resolveExpression(
+          file,
+          expression,
+          locals,
+        );
+        const declaration = reference?.declaration;
+        if (!reference || !declaration || visited.has(declaration))
+          return undefined;
+        visited.add(declaration);
+        if (!ts.isVariableDeclaration(declaration) || !declaration.initializer)
+          return reference;
+        if (
+          !ts.isVariableDeclarationList(declaration.parent) ||
+          !(declaration.parent.flags & ts.NodeFlags.Const)
+        )
+          return undefined;
+        const initializer = unwrapExpression(declaration.initializer);
+        if (
+          !ts.isIdentifier(initializer) &&
+          !ts.isPropertyAccessExpression(initializer)
+        )
+          return reference;
+        const local =
+          ts.isIdentifier(expression) &&
+          locals?.get(expression.text) === declaration;
+        return follow(reference.file, initializer, local ? locals : undefined);
+      }
+      return follow(file, expression, locals);
+    },
     resolveExport(file, exportName) {
       return resolveExport(file, exportName);
     },
@@ -295,6 +346,7 @@ export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
       };
     },
   };
+  return sourceIndex;
 }
 
 export function exportedVariableDeclarations(