@groma/scanner-vue 0.2.1 → 0.2.3

package/README.md

@@ -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

@@ -39745,13 +39745,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);
@@ -39762,9 +39762,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) {
@@ -39775,8 +39773,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,
@@ -39786,14 +39782,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 {};
@@ -39902,10 +39898,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) {
@@ -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;

package/package.json

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