@groma/scanner-typescript 0.1.0 → 0.1.1

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@groma/scanner-typescript",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "TypeScript source and call evidence using the native TypeScript SDK.",
   "private": false,
   "type": "module",
   "license": "MIT",
   "os": [
-    "win32",
     "linux",
-    "darwin"
+    "darwin",
+    "win32"
   ],
   "cpu": [
     "arm64",
@@ -43,10 +43,7 @@
           }
         ],
         "compatibility": {
-          "groma": "^0.3.0",
-          "technologyVersions": {
-            "typescript": "5.9.2 || 5.9.3 || 7.0.2"
-          }
+          "groma": "^0.3.0"
         }
       }
     }

package/src/index.js

@@ -3803,9 +3803,9 @@ async function listTypeScriptFiles(repositoryRoot, config = defaultTypeScriptSca
 }
 
 // plugins/scanners/typescript/src/scan.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import path6 from "path";
+import path9 from "path";
 
 // node_modules/typescript/lib/version.cjs
 var { version } = require_package();
@@ -3975,7 +3975,7 @@ function sourcePosition(position) {
 
 // plugins/scanners/typescript/src/graph.ts
 import { readFile } from "fs/promises";
-import path5 from "path";
+import path8 from "path";
 
 // plugins/scanners/typescript/src/naming.ts
 function kebabCase(name) {
@@ -3990,7 +3990,7 @@ function displayName(kebab) {
 }
 
 // plugins/scanners/typescript/src/source-analysis.ts
-import path4 from "path";
+import path7 from "path";
 
 // node_modules/typescript/dist/enums/checkFlags.js
 var CheckFlags;
@@ -17378,8 +17378,6 @@ function importBindings(source, dependencies) {
     if (!isImportDeclaration(statement) || !isStringLiteral(statement.moduleSpecifier))
       continue;
     const specifier = statement.moduleSpecifier.text;
-    if (!specifier.startsWith("."))
-      continue;
     const clause = statement.importClause;
     const names = clause ? bindingNames(clause) : [];
     if (names.length === 0 && clause?.phaseModifier !== SyntaxKind.TypeKeyword)
@@ -17433,8 +17431,94 @@ async function usedImportSpecifiers(source, checker) {
   return [...dependencies];
 }
 
-// plugins/scanners/typescript/src/source-operations.ts
+// plugins/scanners/typescript/src/projects.ts
+import path4 from "path";
+import { stat } from "fs/promises";
+
+// plugins/scanners/projects.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync2 } from "fs";
 import path3 from "path";
+import { promisify } from "util";
+var execute = promisify(execFile);
+var excluded = new Set([
+  ".git",
+  "node_modules",
+  "vendor",
+  "target",
+  "dist",
+  "build",
+  "bin",
+  "obj",
+  ".gradle",
+  ".angular",
+  "coverage",
+  "generated",
+  "groma",
+  ".groma"
+]);
+async function projectFiles(root, matches) {
+  const { stdout } = await execute("git", ["-C", root, "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { maxBuffer: 64 * 1024 * 1024 });
+  return [...new Set(stdout.split("\x00").filter((file) => file && matches(file) && !file.split("/").some((part) => excluded.has(part)) && existsSync2(path3.join(root, file))))].sort();
+}
+
+// plugins/scanners/typescript/src/projects.ts
+async function typescriptProjects(api, root, files) {
+  const configurations = new Map;
+  async function read(file) {
+    if (configurations.has(file))
+      return;
+    const config = await api.parseConfigFile(file);
+    if (config.errors.length)
+      throw new Error(`${file}: ${config.errors.map((error) => error.text).join(`
+`)}`);
+    configurations.set(file, config);
+    for (const reference of config.projectReferences ?? []) {
+      const target = (await stat(reference.path)).isDirectory() ? path4.join(reference.path, "tsconfig.json") : reference.path;
+      await read(target);
+    }
+  }
+  for (const file of await projectFiles(root, (file) => path4.posix.basename(file) === "tsconfig.json"))
+    await read(path4.join(root, file));
+  const selected = new Set(files.map((file) => path4.resolve(root, file)));
+  const projects = [...configurations].map(([key, config]) => ({
+    key,
+    config,
+    files: config.fileNames.filter((file) => selected.has(path4.resolve(file)))
+  }));
+  const owners = new Map;
+  for (const project of projects) {
+    for (const file of project.files) {
+      const previous = owners.get(path4.resolve(file));
+      if (!previous || path4.dirname(project.key).split(path4.sep).length >= path4.dirname(previous.key).split(path4.sep).length) {
+        owners.set(path4.resolve(file), project);
+      }
+    }
+  }
+  for (const project of projects)
+    project.files = project.files.filter((file) => owners.get(path4.resolve(file)) === project);
+  const loose = [...selected].filter((file) => !owners.has(file));
+  return [...projects.filter((project) => project.files.length), ...loose.length ? [{ key: "", files: loose }] : []];
+}
+
+// plugins/scanners/typescript/src/source-imports.ts
+import path5 from "path";
+async function resolvedImports(root, source, specifiers, checker) {
+  const used = new Set(specifiers);
+  const nodes = [];
+  function visit(node) {
+    if (isStringLiteral(node) && used.has(node.text))
+      nodes.push(node);
+    node.forEachChild(visit);
+  }
+  visit(source);
+  const symbols = await checker.getSymbolAtLocation(nodes);
+  const declarations = await Promise.all(symbols.flatMap((symbol) => symbol?.declarations ?? []).map((handle) => handle.resolve()));
+  return [...new Set(declarations.flatMap((declaration) => declaration ? [path5.relative(root, declaration.getSourceFile().fileName).split(path5.sep).join("/")] : []))].sort();
+}
+
+// plugins/scanners/typescript/src/source-operations.ts
+import path6 from "path";
 
 // plugins/scanners/typescript/src/source-tokens.ts
 function lookup(scope, name) {
@@ -17656,7 +17740,7 @@ function executable(node) {
 function location(root, node) {
   const source = node.getSourceFile();
   return {
-    file: path3.relative(root, source.fileName).split(path3.sep).join("/"),
+    file: path6.relative(root, source.fileName).split(path6.sep).join("/"),
     line: source.getLineAndCharacterOfPosition(node.getStart()).line + 1,
     position: node.getStart()
   };
@@ -17941,85 +18025,83 @@ async function analyzeSourceFiles(repositoryRoot, paths) {
     return { files: [], operations: [], invocations: [] };
   const api = new API({ cwd: repositoryRoot });
   try {
-    const program = await api.createProgram(paths.map((file) => path4.join(repositoryRoot, file)), {
-      compilerOptions: {
-        noLib: true,
-        noResolve: true,
-        types: [],
-        allowJs: true,
-        moduleResolution: ModuleResolutionKind.Bundler,
-        module: ModuleKind.Preserve
+    const result = { files: [], operations: [], invocations: [] };
+    for (const project of await typescriptProjects(api, repositoryRoot, paths)) {
+      if (!project.config) {
+        const analyzed = new Set(result.files.map((file) => path7.resolve(repositoryRoot, file.file)));
+        project.files = project.files.filter((file) => !analyzed.has(file));
+        if (!project.files.length)
+          continue;
       }
-    });
-    const sources = await Promise.all(paths.map(async (file) => {
-      const source = await program.getSourceFile(path4.join(repositoryRoot, file));
-      if (!source)
-        throw new Error(`TypeScript could not parse ${file}`);
-      return source;
-    }));
-    const evidence = await sourceOperations(repositoryRoot, sources, program.getProject().checker);
-    const files = await Promise.all(sources.map(async (source, index) => ({
-      file: paths[index],
-      specifiers: await usedImportSpecifiers(source, program.getProject().checker),
-      symbols: exportSymbols(paths[index], source)
-    })));
-    return { files, ...evidence };
+      const evidence = await analyzeProject(api, repositoryRoot, paths, project);
+      result.files.push(...evidence.files);
+      result.operations.push(...evidence.operations);
+      result.invocations.push(...evidence.invocations);
+    }
+    result.operations = [...new Map(result.operations.map((operation) => [operation.id, operation])).values()];
+    return result;
   } finally {
     await api.close();
   }
 }
+async function analyzeProject(api, repositoryRoot, paths, project) {
+  const program = await api.createProgram(project.files, {
+    compilerOptions: { ...project.config?.options ?? {
+      noLib: true,
+      types: [],
+      allowJs: true,
+      moduleResolution: ModuleResolutionKind.Bundler,
+      module: ModuleKind.Preserve
+    }, noEmit: true }
+  });
+  const sources = await Promise.all(paths.map((file) => program.getSourceFile(path7.join(repositoryRoot, file))));
+  const selectedProgramSources = sources.filter((source) => source !== undefined);
+  const checker = program.getProject().checker;
+  const evidence = await sourceOperations(repositoryRoot, selectedProgramSources, checker);
+  const files = await Promise.all(selectedProgramSources.map(async (source) => {
+    const file = path7.relative(repositoryRoot, source.fileName).split(path7.sep).join("/");
+    return {
+      file,
+      imports: await resolvedImports(repositoryRoot, source, await usedImportSpecifiers(source, checker), checker),
+      symbols: exportSymbols(file, source)
+    };
+  }));
+  return { files, ...evidence };
+}
 
 // plugins/scanners/typescript/src/graph.ts
-function resolveSpecifier(fromFile, specifier, files) {
-  if (!specifier.startsWith("."))
-    return;
-  const joined = path5.posix.normalize(path5.posix.join(path5.posix.dirname(fromFile), specifier));
-  const candidates = specifier.endsWith(".ts") || specifier.endsWith(".tsx") ? [joined] : [
-    joined,
-    joined.replace(/\.jsx?$/, ".ts"),
-    joined.replace(/\.jsx?$/, ".tsx"),
-    `${joined}.ts`,
-    `${joined}.tsx`,
-    `${joined}.js`,
-    `${joined}/index.ts`,
-    `${joined}/index.tsx`
-  ];
-  return candidates.find((candidate) => files.has(candidate));
-}
 function fileStem(file) {
-  return path5.posix.basename(file).replace(/\.tsx?$/, "");
+  return path8.posix.basename(file).replace(/\.tsx?$/, "");
 }
 function fileLabel(file) {
   const stem = fileStem(file);
   if (stem === "index") {
-    const parent = path5.posix.basename(path5.posix.dirname(file));
+    const parent = path8.posix.basename(path8.posix.dirname(file));
     return displayName(kebabCase(parent === "." || parent === "" ? stem : parent));
   }
   return displayName(kebabCase(stem));
 }
 async function packageName(repositoryRoot) {
   try {
-    const source = await readFile(path5.join(repositoryRoot, "package.json"), "utf8");
+    const source = await readFile(path8.join(repositoryRoot, "package.json"), "utf8");
     const name = JSON.parse(source).name;
     if (typeof name === "string" && kebabCase(name) !== "") {
       return displayName(kebabCase(name));
     }
   } catch {}
-  return displayName(kebabCase(path5.basename(repositoryRoot)));
+  return displayName(kebabCase(path8.basename(repositoryRoot)));
 }
 async function buildImportGraph(repositoryRoot, config = defaultTypeScriptScannerConfig) {
   const paths = await listTypeScriptFiles(repositoryRoot, config);
   const files = new Set(paths);
   const { files: analyses, operations, invocations } = await analyzeSourceFiles(repositoryRoot, paths);
-  const nodes = new Map(analyses.map(({ file, specifiers, symbols }) => [file, {
-    file,
-    imports: [...new Set(specifiers.flatMap((specifier) => {
-      const resolved = resolveSpecifier(file, specifier, files);
-      return resolved === undefined ? [] : [resolved];
-    }))].sort(),
-    importedBy: [],
-    symbols
-  }]));
+  const nodes = new Map;
+  for (const analysis of analyses) {
+    const node = nodes.get(analysis.file) ?? { file: analysis.file, imports: [], importedBy: [], symbols: [] };
+    node.imports = [...new Set([...node.imports, ...analysis.imports.filter((file) => files.has(file))])].sort();
+    node.symbols = [...new Map([...node.symbols, ...analysis.symbols].map((symbol) => [symbol.id, symbol])).values()];
+    nodes.set(node.file, node);
+  }
   for (const node of nodes.values()) {
     for (const imported of node.imports)
       nodes.get(imported)?.importedBy.push(node.file);
@@ -18036,7 +18118,7 @@ function isPaintFile(file, node) {
 }
 async function packageBins(repositoryRoot) {
   try {
-    const source = await readFile2(path6.join(repositoryRoot, "package.json"), "utf8");
+    const source = await readFile2(path9.join(repositoryRoot, "package.json"), "utf8");
     const bin = JSON.parse(source).bin;
     if (typeof bin === "string")
       return [bin.replace(/^\.\//, "")];
@@ -18098,8 +18180,8 @@ function inferScopeFiles(graph, bins) {
   return [...scopes].sort();
 }
 function commonDirectorySegments(left, right) {
-  const leftParts = path6.posix.dirname(left).split("/");
-  const rightParts = path6.posix.dirname(right).split("/");
+  const leftParts = path9.posix.dirname(left).split("/");
+  const rightParts = path9.posix.dirname(right).split("/");
   let count = 0;
   while (leftParts[count] !== undefined && leftParts[count] === rightParts[count])
     count += 1;
@@ -18149,7 +18231,7 @@ function scopeNames(scopeFiles) {
   for (const file of scopeFiles) {
     let name = fileStem(file) === "cli" ? "Cli" : fileLabel(file);
     if (used.has(name)) {
-      name = displayName(kebabCase(`${path6.posix.basename(path6.posix.dirname(file))}-${fileStem(file)}`));
+      name = displayName(kebabCase(`${path9.posix.basename(path9.posix.dirname(file))}-${fileStem(file)}`));
     }
     if (used.has(name))
       name = `${name} ${file}`;
@@ -18179,7 +18261,7 @@ async function scanTypeScriptSource(repositoryRoot, config = defaultTypeScriptSc
         id: "package",
         kind: "package",
         name,
-        ...existsSync2(path6.join(repositoryRoot, "package.json")) ? { file: "package.json" } : {}
+        ...existsSync3(path9.join(repositoryRoot, "package.json")) ? { file: "package.json" } : {}
       },
       ...scopeFiles.map((file) => ({
         id: scopeId(file),
@@ -18197,7 +18279,7 @@ async function scanTypeScriptSource(repositoryRoot, config = defaultTypeScriptSc
 }
 
 // plugins/scanners/typescript/src/structure.ts
-import path7 from "path";
+import path10 from "path";
 function isExported(modifierFlags) {
   return (modifierFlags & ModifierFlags.Export) !== 0;
 }
@@ -18278,7 +18360,7 @@ function declarationsIn(source, symbols) {
 async function readCodeStructure(repositoryRoot, references) {
   if (references.length === 0)
     return [];
-  const filenames = references.map((reference) => path7.join(repositoryRoot, reference.file));
+  const filenames = references.map((reference) => path10.join(repositoryRoot, reference.file));
   const api = new API({ cwd: repositoryRoot });
   try {
     const snapshot = await api.updateSnapshot({ openFiles: filenames });
@@ -18303,7 +18385,7 @@ async function readCodeStructure(repositoryRoot, references) {
 var scanner2 = {
   id: "typescript",
   readCodeStructure,
-  watch: { include: defaultTypeScriptScannerConfig.globs, exclude: defaultTypeScriptScannerConfig.ignore },
+  watch: { include: [...defaultTypeScriptScannerConfig.globs, "**/tsconfig*.json", "**/package.json"], exclude: defaultTypeScriptScannerConfig.ignore },
   scan: (root) => scanTypeScriptSource(root)
 };
 var src_default = scanner2;