@groma/scanner-vue 0.2.2 → 0.2.4

package/README.md

@@ -14,7 +14,7 @@ bun plugins/scanners/vue/build.ts
 In the project being scanned:
 
 ```sh
-groma scanner add /absolute/path/to/groma/plugins/scanners/vue/dist/package
+groma plugin add /absolute/path/to/groma/plugins/scanners/vue/dist/package
 groma scan
 ```
 
@@ -30,7 +30,15 @@ configuration, SFC parsing, template code generation and original-source
 mappings. [Volar](https://github.com/volarjs/volar.js) integrates the generated
 code with the TypeScript checker, which resolves component imports and handler
 function identities. The scanner translates these facts into the existing
-supplied-callback evidence contract; it has no separate name or type resolver.
+supplied-callback evidence contract; it has no separate type resolver, and its
+only own name lookup is a template tag that no import names, on Vue's
+`GlobalComponents`.
+
+A root `tsconfig.json` that names no source and references other configs, as
+in Nuxt 4, compiles a package through the first existing referenced config that
+includes one of its SFCs, with that config's declaration files even when Git
+ignores them. Before the framework generates those configs, the root config's
+own settings apply.
 
 The package declares the default
 [include and exclude lists](../index.md#selecting-source-files). It includes
@@ -65,7 +73,13 @@ trigger the existing shared scanner refresh.
 ### Inline event bindings
 
 The qualified example is Vue REPL's CodeMirror `change` event bound to the
-parent's `onChange` function. A static imported SFC must assign `defineEmits`
+parent's `onChange` function. The child is a static imported SFC or, when no
+import names the tag, an SFC registered for every template on Vue's
+`GlobalComponents` as `Name: typeof import('./Name.vue')['default']`, the form
+Nuxt and unplugin-vue-components generate. An import shadows a global
+registration of the same name, and `<game-tile>` finds `GameTile`. Global
+registrations need Vue installed and the generated declarations present, as
+after `nuxt prepare`. The child must assign `defineEmits`
 to a constant and declare the event in a type literal, function type, or
 literal runtime array. A call to that same symbol must supply a declared
 literal event name inside a source function or directly in an inline template

package/dist/index.js

@@ -40037,6 +40037,32 @@ function projectConfig(root, repositoryRoot, files) {
       throw new Error(`${root}: no TypeScript config in the package or its repository ancestors`);
   }
 }
+function readConfig(configFile) {
+  const vue = import_language_core.createParsedCommandLine(vueTypeScript, ts.sys, configFile);
+  const plugin = import_language_core.createVueLanguagePlugin(vueTypeScript, vue.options, vue.vueOptions, (id) => id);
+  const parsed = ts.parseJsonSourceFileConfigFileContent(ts.readJsonConfigFile(configFile, ts.sys.readFile), ts.sys, path2.dirname(configFile), {}, configFile, undefined, plugin.typescript.extraFileExtensions);
+  return { configFile, vueOptions: vue.vueOptions, plugin, parsed };
+}
+function sourceConfig(configFile, packageSfc) {
+  const config = readConfig(configFile);
+  if (config.parsed.fileNames.length)
+    return config;
+  for (const reference of config.parsed.projectReferences ?? []) {
+    const referencedFile = ts.resolveProjectReferencePath(reference);
+    if (!ts.sys.fileExists(referencedFile))
+      continue;
+    const referenced = readConfig(referencedFile);
+    if (referenced.parsed.fileNames.some(packageSfc))
+      return referenced;
+  }
+  return config;
+}
+function defaultExport(index) {
+  return ts.isLiteralTypeNode(index) && ts.isStringLiteral(index.literal) && index.literal.text === "default";
+}
+function pascalCase(tag) {
+  return tag.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(/^\w/, (letter) => letter.toUpperCase());
+}
 
 class VueProject {
   program;
@@ -40045,6 +40071,7 @@ class VueProject {
   root;
   options;
   diagnostics;
+  globals;
   language;
   plugin;
   readable;
@@ -40056,13 +40083,9 @@ class VueProject {
       const local = relative(repositoryRoot, file);
       return (owners.get(local) ?? root) === root && (local.startsWith("../") || files.has(local));
     };
-    const configFile = projectConfig(root, repositoryRoot, files);
-    const configRoot = path2.dirname(configFile);
-    const config = ts.readJsonConfigFile(configFile, ts.sys.readFile);
-    const vue = import_language_core.createParsedCommandLine(vueTypeScript, ts.sys, configFile);
-    this.options = vue.vueOptions;
-    this.plugin = import_language_core.createVueLanguagePlugin(vueTypeScript, vue.options, vue.vueOptions, (id) => id);
-    const parsed = ts.parseJsonSourceFileConfigFileContent(config, ts.sys, configRoot, {}, configFile, undefined, this.plugin.typescript.extraFileExtensions);
+    const { configFile, vueOptions, plugin, parsed } = sourceConfig(projectConfig(root, repositoryRoot, files), (file) => file.endsWith(".vue") && selected(file));
+    this.options = vueOptions;
+    this.plugin = plugin;
     failDiagnostics(parsed.errors.filter((item) => item.code !== 5083));
     this.diagnostics = parsed.errors.filter((item) => item.code === 5083).map((item) => ({
       severity: "warning",
@@ -40079,7 +40102,7 @@ class VueProject {
         this.language = language;
       }
     }))({
-      rootNames: [...new Set([...assigned, ...parsed.fileNames.filter((file) => selected(file) || !ts.sys.fileExists(file))])],
+      rootNames: [...new Set([...assigned, ...parsed.fileNames.filter((file) => selected(file) || !ts.sys.fileExists(file) || /\.d\.[cm]?ts$/.test(file))])],
       options: parsed.options,
       host
     });
@@ -40091,6 +40114,11 @@ class VueProject {
       message: `A declared TypeScript source is absent; available source was still scanned. ${ts.flattenDiagnosticMessageText(item.messageText, " ")}`
     })));
     this.checker = this.program.getTypeChecker();
+    const vueResolution = ts.resolveModuleName("vue", path2.join(root, "package.json"), parsed.options, host).resolvedModule;
+    const vueSource = vueResolution && this.program.getSourceFile(vueResolution.resolvedFileName);
+    const vueModule = vueSource && this.checker.getSymbolAtLocation(vueSource);
+    const exported = vueModule && this.checker.getExportsOfModule(vueModule).find((symbol) => symbol.name === "GlobalComponents");
+    this.globals = exported && this.checker.getDeclaredTypeOfSymbol(exported);
     this.files = this.program.getSourceFiles().filter((source) => this.owned(source) && selected(source.fileName));
     for (const source of this.files)
       this.validateSfc(source.fileName);
@@ -40098,6 +40126,16 @@ class VueProject {
   owned(source) {
     return !source.isDeclarationFile && !relative(this.root, source.fileName).startsWith("../") && !source.fileName.includes("/node_modules/") && this.readable.has(relative(this.root, source.fileName));
   }
+  globalComponents(tag) {
+    return (this.globals?.getProperty(pascalCase(tag))?.declarations ?? []).flatMap((declaration) => {
+      const type = ts.isPropertySignature(declaration) ? declaration.type : undefined;
+      if (!type || !ts.isIndexedAccessTypeNode(type) || !ts.isImportTypeNode(type.objectType) || !defaultExport(type.indexType))
+        return [];
+      const source = this.checker.getTypeFromTypeNode(type.objectType).getSymbol()?.valueDeclaration;
+      const sfc = source && ts.isSourceFile(source) && this.owned(source) && this.sfc(source.fileName);
+      return sfc ? [sfc] : [];
+    });
+  }
   sfc(file) {
     const code = this.language.scripts.get(file)?.generated?.root;
     return code instanceof import_language_core.VueVirtualCode ? code : undefined;
@@ -40238,24 +40276,23 @@ class VueEvidence {
       }
     }
   }
-  component(file, position) {
-    const candidates = new Set;
-    for (const node of this.project.nodes(file, position)) {
-      if (!ts2.isIdentifier(node))
-        continue;
-      const symbol = this.project.checker.getSymbolAtLocation(node);
-      if (!symbol || !(symbol.flags & ts2.SymbolFlags.Alias))
-        continue;
-      const target = this.project.checker.getAliasedSymbol(symbol);
-      for (const declaration of target.declarations ?? []) {
-        const source = declaration.getSourceFile();
-        const sfc = this.project.owned(source) && this.project.sfc(source.fileName);
-        if (sfc)
-          candidates.add(sfc);
-      }
-    }
+  component(file, element, position) {
+    const candidates = new Set(this.importedComponents(file, position) ?? this.project.globalComponents(element.tag));
     return candidates.size === 1 ? [...candidates][0] : undefined;
   }
+  importedComponents(file, position) {
+    const aliases = this.project.nodes(file, position).flatMap((node) => {
+      const symbol = ts2.isIdentifier(node) ? this.project.checker.getSymbolAtLocation(node) : undefined;
+      return symbol && symbol.flags & ts2.SymbolFlags.Alias ? [this.project.checker.getAliasedSymbol(symbol)] : [];
+    });
+    if (!aliases.length)
+      return;
+    return aliases.flatMap((target) => (target.declarations ?? []).flatMap((declaration) => {
+      const source = declaration.getSourceFile();
+      const sfc = this.project.owned(source) && this.project.sfc(source.fileName);
+      return sfc ? [sfc] : [];
+    }));
+  }
   handler(file, position) {
     const candidates = new Set;
     for (const node of this.project.nodes(file, position)) {
@@ -40380,7 +40417,7 @@ class VueEvidence {
     const statement = expression.statements[0];
     if (expression.statements.length !== 1 || !statement || !ts2.isExpressionStatement(statement) || !ts2.isIdentifier(statement.expression))
       return false;
-    const child = this.component(file, templateOffset + element.loc.start.offset + 1);
+    const child = this.component(file, element, templateOffset + element.loc.start.offset + 1);
     const target = this.handler(file, templateOffset + event.exp.loc.start.offset);
     if (!child || !target)
       return false;
@@ -42033,20 +42070,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);
@@ -42060,7 +42109,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);
@@ -42077,7 +42127,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groma/scanner-vue",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Complementary Vue framework evidence; a dependency declaration does not verify runtime use.",
   "private": false,
   "type": "module",