@groma/scanner-angular 0.2.1 → 0.2.3

package/README.md

@@ -16,7 +16,7 @@ bun plugins/scanners/angular/build.ts
 From the project being scanned:
 
 ```sh
-groma scanner add /absolute/path/to/groma/plugins/scanners/angular/dist/package
+groma plugin add /absolute/path/to/groma/plugins/scanners/angular/dist/package
 groma scan
 ```
 

package/dist/index.js

@@ -254,31 +254,33 @@ function configOwners(wanted, configs) {
   }
   return owners;
 }
+function programWithOwnedSources(program, paths) {
+  return { program, owned: new Set(paths.map((file) => program.getSourceFile(file))) };
+}
 function angularPrograms(root, files, configs) {
   const wanted = new Set(files.map((file) => path3.resolve(root, file)));
   const owners = configOwners(wanted, configs);
   const groups = new Map;
   for (const [file, owner] of owners)
     groups.set(owner, [...groups.get(owner) ?? [], file]);
-  const programs = [...groups].map(([owner, rootNames]) => ({
-    program: ts.createProgram(rootNames, { ...owner.config.options, noEmit: true }),
-    files: new Set(rootNames)
-  }));
+  const programs = [...groups].map(([owner, rootNames]) => programWithOwnedSources(ts.createProgram(rootNames, { ...owner.config.options, noEmit: true }), rootNames));
   const loose = [];
   for (const file of wanted) {
     if (owners.has(file))
       continue;
-    const importer = programs.find(({ program }) => program.getSourceFile(file) !== undefined);
+    const readers = programs.filter(({ program }) => program.getSourceFile(file) !== undefined);
+    if (readers.some(({ program, owned }) => owned.has(program.getSourceFile(file))))
+      continue;
+    const [importer] = readers;
     if (importer)
-      importer.files.add(file);
+      importer.owned.add(importer.program.getSourceFile(file));
     else
       loose.push(file);
   }
   if (loose.length)
-    programs.push({ program: ts.createProgram(loose, { noEmit: true }), files: new Set(loose) });
-  return programs.map(({ program, files: own }) => {
-    const owned = [...own].map((file) => program.getSourceFile(file));
-    failDiagnostics(owned.flatMap((source) => program.getSyntacticDiagnostics(source)));
+    programs.push(programWithOwnedSources(ts.createProgram(loose, { noEmit: true }), loose));
+  return programs.map(({ program, owned }) => {
+    failDiagnostics([...owned].flatMap((source) => program.getSyntacticDiagnostics(source)));
     return { program, owned, sources: program.getSourceFiles().filter((source) => inRepository(root, source)) };
   });
 }
@@ -28400,13 +28402,13 @@ function compare(...values) {
 }
 function uniqueBy(values, key, label) {
   const seen = new Set;
-  for (const value of values) {
-    const id = key(value);
+  const keyed = values.map((value) => ({ id: key(value), value }));
+  for (const { id } of keyed) {
     if (seen.has(id))
       throw new Error(`duplicate ${label}: ${id}`);
     seen.add(id);
   }
-  return [...values].sort((left, right) => key(left).localeCompare(key(right)));
+  return keyed.sort((left, right) => left.id.localeCompare(right.id)).map((entry) => entry.value);
 }
 function createScanObservation(input) {
   const roots = validateRoots(input.roots);
@@ -28417,9 +28419,7 @@ function createScanObservation(input) {
     symbols: [...new Map(file.symbols.map((symbol) => [
       compare(symbol.id, symbol.kind),
       symbol
-    ])).values()].sort((left, right) => {
-      return compare(left.id, left.kind).localeCompare(compare(right.id, right.kind));
-    })
+    ]))].sort(([left], [right]) => left.localeCompare(right)).map(([, symbol]) => symbol)
   })), (file) => file.file, "file path");
   const filePaths = new Set(files.map((file) => file.file));
   for (const file of files) {
@@ -28430,8 +28430,6 @@ function createScanObservation(input) {
         throw new Error(`file references unknown root: ${root}`);
     }
   }
-  for (const diagnostic of input.diagnostics)
-    diagnosticLocation(diagnostic);
   return {
     schemaVersion: 1,
     scanner: input.scanner,
@@ -28441,14 +28439,14 @@ function createScanObservation(input) {
     ...entryPoints(input.entryPoints, filePaths),
     ...operationEvidence(input, filePaths),
     ...httpEvidence(input.httpEndpoints, input.httpRequests, input.operations && new Set(input.operations.map((operation) => operation.id))),
-    diagnostics: [...new Map(input.diagnostics.map((diagnostic) => [
-      diagnosticKey(diagnostic),
-      diagnostic
-    ])).values()].sort((left, right) => {
-      return diagnosticKey(left).localeCompare(diagnosticKey(right));
-    })
+    diagnostics: normalizeScanDiagnostics(input.diagnostics)
   };
 }
+function normalizeScanDiagnostics(diagnostics) {
+  for (const diagnostic of diagnostics)
+    diagnosticLocation(diagnostic);
+  return [...new Map(diagnostics.map((diagnostic) => [diagnosticKey(diagnostic), diagnostic]))].sort(([left], [right]) => left.localeCompare(right)).map(([, diagnostic]) => diagnostic);
+}
 function entryPoints(input, paths) {
   if (input === undefined)
     return {};
@@ -28557,10 +28555,14 @@ function operationTokens(operation) {
   const endLine = Number(operation.endLine);
   if (endLine < startLine)
     throw new Error("operation.endLine must be at or after startLine");
+  const tokens = array(operation.tokens, "operation.tokens");
+  tokens.forEach((token) => {
+    string(token, "operation.token");
+  });
   return {
     startLine,
     endLine,
-    tokens: array(operation.tokens, "operation.tokens").map((token) => string(token, "operation.token"))
+    tokens
   };
 }
 function validateOperationTokens(operation) {
@@ -28710,20 +28712,32 @@ function reachedFiles(entry, compiled, imports, packages, units) {
 }
 async function declaredEntries(root, declarations, packages, workspaces) {
   const entries = [];
+  const diagnostics = [];
   for (const file of declarations) {
     const text = await readFile3(path5.join(root, file), "utf8");
     const name = path5.posix.basename(file);
-    if (name === "package.json") {
-      const manifest = JSON.parse(text);
-      entries.push(...declaredBins(file, manifest), ...declaredScripts(file, manifest.scripts));
-    } else if (name === "angular.json")
-      entries.push(...angularEntries(file, text));
-    else if (name === "project.json")
-      entries.push(...nxEntries(file, text, workspaces));
-    else if (file.endsWith(".html"))
-      entries.push(...browserEntries(file, text, packages));
+    try {
+      if (name === "package.json") {
+        const manifest = JSON.parse(text);
+        entries.push(...declaredBins(file, manifest), ...declaredScripts(file, manifest.scripts));
+      } else if (name === "angular.json")
+        entries.push(...angularEntries(file, text));
+      else if (name === "project.json")
+        entries.push(...nxEntries(file, text, workspaces));
+      else if (file.endsWith(".html"))
+        entries.push(...browserEntries(file, text, packages));
+    } catch (error) {
+      if (!(error instanceof SyntaxError))
+        throw error;
+      diagnostics.push({
+        severity: "warning",
+        code: "JAVASCRIPT_MANIFEST_INVALID",
+        file,
+        message: `The file is not valid JSON; the entry points it declares are not read. ${error.message}`
+      });
+    }
   }
-  return entries;
+  return { entries, diagnostics };
 }
 function sourced(entry, files, outputs = []) {
   const file = sourceOf(entry.file, outputs, files);
@@ -28737,7 +28751,8 @@ async function withJavaScriptEntries(root, observation, inputs, files) {
   const packages = new Set(inventory.filter((file) => path5.posix.basename(file) === "package.json").map((file) => path5.posix.dirname(file)));
   const active = new Set(observation.files.map((file) => packageFor(file.file, packages)));
   const declarations = inventory.filter((file) => path5.posix.basename(file) !== "nx.json" && active.has(packageFor(file, packages)));
-  const entries = [...inputs.entries, ...await declaredEntries(root, declarations, packages, workspaces)];
+  const declared = await declaredEntries(root, declarations, packages, workspaces);
+  const entries = [...inputs.entries, ...declared.entries];
   const inventoryFiles = [...observation.files];
   const visible = new Set(inventoryFiles.map((file) => file.file));
   const readable = new Set(files);
@@ -28754,7 +28769,12 @@ async function withJavaScriptEntries(root, observation, inputs, files) {
     }
     return [{ ...entry, files: [...new Set([entry.file, ...members.map((file) => file.file)])] }];
   });
-  return createScanObservation({ ...observation, files: inventoryFiles, entryPoints });
+  return createScanObservation({
+    ...observation,
+    files: inventoryFiles,
+    entryPoints,
+    diagnostics: [...observation.diagnostics, ...declared.diagnostics]
+  });
 }
 
 // plugins/scanners/entry-points/source.ts
@@ -30039,17 +30059,16 @@ async function scanProject(root, directory, programs, inputs, readable) {
   const httpRequests = [];
   for (const { program, owned, sources } of programs) {
     const checker = program.getTypeChecker();
-    const mine = new Set(owned);
     const directives = sources.filter((source) => readable.has(relative(root, source.fileName))).flatMap((source) => source.statements.filter(ts6.isClassDeclaration).flatMap((node) => sourceDirective(node, checker) ?? []));
-    for (const component of directives.filter((directive) => directive.view && mine.has(directive.declaration.getSourceFile()))) {
+    for (const component of directives.filter((directive) => directive.view && owned.has(directive.declaration.getSourceFile()))) {
       templates.bindOutputs(component, directives, checker);
       sourceUnits.push(templates.unit(component));
     }
     httpRequests.push(...await angularHttpRequests(sources, checker, (node) => {
-      const caller = mine.has(node.getSourceFile()) ? enclosingOperation(node) : undefined;
+      const caller = owned.has(node.getSourceFile()) ? enclosingOperation(node) : undefined;
       return caller && evidence.operationId(caller);
     }));
-    files.push(...owned.map((source) => ({
+    files.push(...[...owned].map((source) => ({
       file: relative(root, source.fileName),
       symbols: source.statements.filter(ts6.isClassDeclaration).map((node) => ({
         id: `${relative(root, source.fileName)}#${node.getStart()}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groma/scanner-angular",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Complementary Angular framework evidence with its own compatible TypeScript tooling.",
   "private": false,
   "type": "module",