king-design-analyzer 2.2.2 → 2.2.4

package/dist/{chunk-YRGYDK2I.mjs → chunk-ZW3HD2OD.mjs}

@@ -1,10 +1,10 @@
-import { resolveMetadataInheritance, resolvePackageResourceDir } from './chunk-QC6VTSA3.mjs';
+import { resolveMetadataInheritance, resolvePackageResourceDir, resolvePackageRoot } from './chunk-QC6VTSA3.mjs';
 import { __commonJS, __toESM } from './chunk-UJCSKKID.mjs';
 import * as fs from 'fs/promises';
-import * as fsSync from 'fs';
-import * as path from 'path';
+import * as fs3 from 'fs';
+import * as path3 from 'path';
 import { parse } from '@vue/compiler-sfc';
-import * as ts from 'typescript';
+import * as ts2 from 'typescript';
 
 // node_modules/@vue/shared/dist/shared.cjs.prod.js
 var require_shared_cjs_prod = __commonJS({
@@ -16806,27 +16806,27 @@ var require_util = __commonJS({
       };
     }
     var normalize = lruMemoize(function normalize2(aPath) {
-      var path3 = aPath;
+      var path4 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path3 = url.path;
+        path4 = url.path;
       }
-      var isAbsolute = exports$1.isAbsolute(path3);
+      var isAbsolute = exports$1.isAbsolute(path4);
       var parts = [];
       var start = 0;
       var i = 0;
       while (true) {
         start = i;
-        i = path3.indexOf("/", start);
+        i = path4.indexOf("/", start);
         if (i === -1) {
-          parts.push(path3.slice(start));
+          parts.push(path4.slice(start));
           break;
         } else {
-          parts.push(path3.slice(start, i));
-          while (i < path3.length && path3[i] === "/") {
+          parts.push(path4.slice(start, i));
+          while (i < path4.length && path4[i] === "/") {
             i++;
           }
         }
@@ -16847,18 +16847,18 @@ var require_util = __commonJS({
           }
         }
       }
-      path3 = parts.join("/");
-      if (path3 === "") {
-        path3 = isAbsolute ? "/" : ".";
+      path4 = parts.join("/");
+      if (path4 === "") {
+        path4 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path3;
+        url.path = path4;
         return urlGenerate(url);
       }
-      return path3;
+      return path4;
     });
     exports$1.normalize = normalize;
-    function join3(aRoot, aPath) {
+    function join4(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -16890,7 +16890,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports$1.join = join3;
+    exports$1.join = join4;
     exports$1.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -17104,7 +17104,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join3(urlGenerate(parsed), sourceURL);
+        sourceURL = join4(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -20492,14 +20492,14 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     var whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
     var getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
     var isMemberExpressionBrowser = (exp) => {
-      const path3 = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
+      const path4 = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
       let state = 0;
       let stateStack = [];
       let currentOpenBracketCount = 0;
       let currentOpenParensCount = 0;
       let currentStringType = null;
-      for (let i = 0; i < path3.length; i++) {
-        const char = path3.charAt(i);
+      for (let i = 0; i < path4.length; i++) {
+        const char = path4.charAt(i);
         switch (state) {
           case 0:
             if (char === "[") {
@@ -20535,7 +20535,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
             } else if (char === `(`) {
               currentOpenParensCount++;
             } else if (char === `)`) {
-              if (i === path3.length - 1) {
+              if (i === path4.length - 1) {
                 return false;
               }
               if (!--currentOpenParensCount) {
@@ -27262,14 +27262,14 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     var whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
     var getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
     var isMemberExpressionBrowser = (exp) => {
-      const path3 = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
+      const path4 = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
       let state = 0;
       let stateStack = [];
       let currentOpenBracketCount = 0;
       let currentOpenParensCount = 0;
       let currentStringType = null;
-      for (let i = 0; i < path3.length; i++) {
-        const char = path3.charAt(i);
+      for (let i = 0; i < path4.length; i++) {
+        const char = path4.charAt(i);
         switch (state) {
           case 0:
             if (char === "[") {
@@ -27305,7 +27305,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
             } else if (char === `(`) {
               currentOpenParensCount++;
             } else if (char === `)`) {
-              if (i === path3.length - 1) {
+              if (i === path4.length - 1) {
                 return false;
               }
               if (!--currentOpenParensCount) {
@@ -32208,6 +32208,11 @@ var require_compiler_core = __commonJS({
 function resolveComponentsPath() {
   return resolvePackageResourceDir("components");
 }
+function extractImportSource(importStatement) {
+  if (!importStatement) return void 0;
+  const match = importStatement.match(/from\s+['"]([^'"]+)['"]/);
+  return match?.[1];
+}
 var ComponentRegistry = class {
   constructor() {
     this.components = /* @__PURE__ */ new Map();
@@ -32235,18 +32240,27 @@ var ComponentRegistry = class {
       const files = await fs.readdir(this.metadataPath);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const content = await fs.readFile(path.join(this.metadataPath, file), "utf-8");
+        const content = await fs.readFile(path3.join(this.metadataPath, file), "utf-8");
         const data = JSON.parse(content);
-        rawComponents[data.name] = data;
+        const importSource = data.importSource || data.source || extractImportSource(data.importStatement);
+        const normalizedData = {
+          ...data,
+          fileName: data.fileName || file.replace(/\.json$/, ""),
+          importSource,
+          source: data.source || importSource
+        };
+        rawComponents[`${normalizedData.fileName}:${normalizedData.name}:${normalizedData.importSource || ""}`] = normalizedData;
       }
       for (const data of Object.values(rawComponents)) {
         const resolvedData = resolveMetadataInheritance(data, rawComponents);
-        newComponents.set(resolvedData.name, resolvedData);
+        this.appendComponent(newComponents, resolvedData);
         if (resolvedData.subComponents) {
           for (const sub of resolvedData.subComponents) {
-            newComponents.set(sub.name, {
+            this.appendComponent(newComponents, {
               id: sub.name,
               name: sub.name,
+              source: resolvedData.source,
+              importSource: resolvedData.importSource,
               props: sub.props || [],
               events: sub.events || [],
               slots: sub.slots || [],
@@ -32256,11 +32270,17 @@ var ComponentRegistry = class {
         }
       }
       this.components = newComponents;
-      console.log(`[ComponentRegistry] ${this.loaded ? "Reloaded" : "Loaded"} ${this.components.size} components.`);
+      const totalEntries = Array.from(this.components.values()).reduce((sum, items) => sum + items.length, 0);
+      console.log(`[ComponentRegistry] ${this.loaded ? "Reloaded" : "Loaded"} ${totalEntries} components.`);
     } catch (error) {
       console.error("[ComponentRegistry] Failed to load metadata:", error);
     }
   }
+  appendComponent(target, metadata) {
+    const current = target.get(metadata.name) || [];
+    current.push(metadata);
+    target.set(metadata.name, current);
+  }
   /**
    * 开始监听文件变化
    */
@@ -32268,7 +32288,7 @@ var ComponentRegistry = class {
     if (this.watcher) return;
     try {
       let reloadTimeout = null;
-      this.watcher = fsSync.watch(this.metadataPath, (eventType, filename) => {
+      this.watcher = fs3.watch(this.metadataPath, (eventType, filename) => {
         if (!filename?.endsWith(".json")) return;
         console.log(`[ComponentRegistry] Detected change: ${filename} (${eventType})`);
         if (reloadTimeout) {
@@ -32293,14 +32313,28 @@ var ComponentRegistry = class {
       console.log("[ComponentRegistry] Hot reload disabled.");
     }
   }
-  getComponent(name) {
-    return this.components.get(name);
+  getComponent(name, importSource) {
+    const candidates = this.components.get(name) || [];
+    if (!importSource) return candidates[0];
+    return candidates.find((item) => {
+      const expectedSource = item.importSource || item.source || extractImportSource(item.importStatement);
+      return expectedSource === importSource;
+    }) || candidates[0];
+  }
+  getComponents(name) {
+    return this.components.get(name) || [];
   }
   getAllComponentNames() {
     return Array.from(this.components.keys());
   }
-  isKnownComponent(name) {
-    return this.components.has(name);
+  isKnownComponent(name, importSource) {
+    if (!importSource) {
+      return this.components.has(name);
+    }
+    return this.getComponents(name).some((item) => {
+      const expectedSource = item.importSource || item.source || extractImportSource(item.importStatement);
+      return expectedSource === importSource;
+    });
   }
 };
 var componentRegistry = new ComponentRegistry();
@@ -32335,7 +32369,7 @@ var HooksRegistry = class {
       const files = await fs.readdir(this.metadataPath);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const content = await fs.readFile(path.join(this.metadataPath, file), "utf-8");
+        const content = await fs.readFile(path3.join(this.metadataPath, file), "utf-8");
         const data = JSON.parse(content);
         newHooks.set(data.name, data);
       }
@@ -32356,7 +32390,7 @@ var HooksRegistry = class {
     if (this.watcher) return;
     try {
       let reloadTimeout = null;
-      this.watcher = fsSync.watch(this.metadataPath, (eventType, filename) => {
+      this.watcher = fs3.watch(this.metadataPath, (eventType, filename) => {
         if (!filename?.endsWith(".json")) return;
         console.log(`[HooksRegistry] Detected change: ${filename} (${eventType})`);
         if (reloadTimeout) {
@@ -32405,6 +32439,104 @@ var HooksRegistry = class {
   }
 };
 var hooksRegistry = new HooksRegistry();
+function packagePathSegments(moduleSpecifier) {
+  if (moduleSpecifier.startsWith("@")) {
+    return moduleSpecifier.split("/").slice(0, 2);
+  }
+  return [moduleSpecifier.split("/")[0]];
+}
+function resolveInstalledPackageDir(moduleSpecifier) {
+  const packageRoot = resolvePackageRoot();
+  const segments = packagePathSegments(moduleSpecifier);
+  const cwd = process.cwd();
+  const candidates = [
+    path3.join(cwd, "node_modules", ...segments),
+    path3.join(cwd, "web", "node_modules", ...segments),
+    packageRoot ? path3.join(packageRoot, "node_modules", ...segments) : null,
+    packageRoot ? path3.join(packageRoot, "web", "node_modules", ...segments) : null
+  ].filter((candidate) => Boolean(candidate));
+  return candidates.find((candidate) => fs3.existsSync(candidate)) || null;
+}
+function resolvePackageTypesEntry(moduleSpecifier) {
+  const packageDir = resolveInstalledPackageDir(moduleSpecifier);
+  if (!packageDir) return null;
+  const packageJsonPath = path3.join(packageDir, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+      const declaredEntry = packageJson.types || packageJson.typings;
+      if (declaredEntry) {
+        const resolved = path3.join(packageDir, declaredEntry);
+        if (fs3.existsSync(resolved)) {
+          return resolved;
+        }
+      }
+    } catch {
+    }
+  }
+  const fallbackEntry = path3.join(packageDir, "index.d.ts");
+  return fs3.existsSync(fallbackEntry) ? fallbackEntry : null;
+}
+function inferExportKind(exportName, declarationFile) {
+  if (!declarationFile) return /^[A-Z]/.test(exportName) ? "component" : "value";
+  const normalizedFile = declarationFile.replace(/\\/g, "/");
+  if (normalizedFile.includes("/components/") && /^[A-Z]/.test(exportName)) {
+    return "component";
+  }
+  return "value";
+}
+var PackageExportRegistry = class {
+  constructor() {
+    this.exportsByModule = /* @__PURE__ */ new Map();
+    this.loadedModules = /* @__PURE__ */ new Set();
+  }
+  async load(moduleSpecifier) {
+    if (this.loadedModules.has(moduleSpecifier)) {
+      return;
+    }
+    const entry = resolvePackageTypesEntry(moduleSpecifier);
+    if (!entry) {
+      this.loadedModules.add(moduleSpecifier);
+      this.exportsByModule.set(moduleSpecifier, /* @__PURE__ */ new Map());
+      return;
+    }
+    const program = ts2.createProgram([entry], {
+      target: ts2.ScriptTarget.ES2020,
+      module: ts2.ModuleKind.ESNext,
+      moduleResolution: ts2.ModuleResolutionKind.NodeJs,
+      skipLibCheck: true
+    });
+    const checker = program.getTypeChecker();
+    const sourceFile = program.getSourceFile(entry);
+    if (!sourceFile) {
+      this.loadedModules.add(moduleSpecifier);
+      this.exportsByModule.set(moduleSpecifier, /* @__PURE__ */ new Map());
+      return;
+    }
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    const exportsMap = /* @__PURE__ */ new Map();
+    if (moduleSymbol) {
+      for (const symbol of checker.getExportsOfModule(moduleSymbol)) {
+        const declarationFile = symbol.declarations?.[0]?.getSourceFile().fileName;
+        exportsMap.set(symbol.getName(), {
+          name: symbol.getName(),
+          moduleSpecifier,
+          declarationFile,
+          kind: inferExportKind(symbol.getName(), declarationFile)
+        });
+      }
+    }
+    this.exportsByModule.set(moduleSpecifier, exportsMap);
+    this.loadedModules.add(moduleSpecifier);
+  }
+  getExport(name, moduleSpecifier) {
+    return this.exportsByModule.get(moduleSpecifier)?.get(name);
+  }
+  isKnownExport(name, moduleSpecifier) {
+    return this.exportsByModule.get(moduleSpecifier)?.has(name) || false;
+  }
+};
+var packageExportRegistry = new PackageExportRegistry();
 
 // src/analysis/astReviewer.ts
 var VUE_BUILTINS = /* @__PURE__ */ new Set([
@@ -32743,27 +32875,30 @@ var NESTING_RULES = {
 async function analyzeCodeWithAST(code) {
   await componentRegistry.load();
   await hooksRegistry.load();
+  await packageExportRegistry.load("@king-design/vue");
+  await packageExportRegistry.load("@ksyun-internal/versatile");
   const violations = [];
+  const componentImportContext = /* @__PURE__ */ new Map();
   const { descriptor, errors } = parse(code);
   if (errors.length > 0) {
     return violations;
   }
   const scriptContent = descriptor.scriptSetup?.content || descriptor.script?.content || "";
   if (scriptContent) {
-    const sourceFile = ts.createSourceFile(
+    const sourceFile = ts2.createSourceFile(
       "temp.ts",
       scriptContent,
-      ts.ScriptTarget.Latest,
+      ts2.ScriptTarget.Latest,
       true
     );
-    ts.forEachChild(sourceFile, (node) => {
-      if (ts.isImportDeclaration(node)) {
-        checkImport(node, violations, sourceFile);
+    ts2.forEachChild(sourceFile, (node) => {
+      if (ts2.isImportDeclaration(node)) {
+        checkImport(node, violations, sourceFile, componentImportContext);
       }
     });
   }
   if (descriptor.template?.ast) {
-    checkTemplate(descriptor.template.ast, violations, []);
+    checkTemplate(descriptor.template.ast, violations, [], componentImportContext);
   }
   if (scriptContent && descriptor.template) {
     const scriptBindings = extractScriptBindings(scriptContent);
@@ -32781,25 +32916,25 @@ function extractScriptBindings(scriptContent) {
   JS_GLOBALS.forEach((b) => bindings.add(b));
   try {
     let extractNames2 = function(name) {
-      if (ts.isIdentifier(name)) {
+      if (ts2.isIdentifier(name)) {
         bindings.add(name.text);
-      } else if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+      } else if (ts2.isObjectBindingPattern(name) || ts2.isArrayBindingPattern(name)) {
         name.elements.forEach((element) => {
-          if (ts.isBindingElement(element)) {
+          if (ts2.isBindingElement(element)) {
             extractNames2(element.name);
           }
         });
       }
     }, visit2 = function(node) {
-      if (ts.isVariableStatement(node)) {
+      if (ts2.isVariableStatement(node)) {
         node.declarationList.declarations.forEach((decl) => extractNames2(decl.name));
-      } else if (ts.isFunctionDeclaration(node) && node.name) {
+      } else if (ts2.isFunctionDeclaration(node) && node.name) {
         bindings.add(node.name.text);
-      } else if (ts.isClassDeclaration(node) && node.name) {
+      } else if (ts2.isClassDeclaration(node) && node.name) {
         bindings.add(node.name.text);
-      } else if (ts.isImportDeclaration(node)) {
+      } else if (ts2.isImportDeclaration(node)) {
         const namedBindings = node.importClause?.namedBindings;
-        if (namedBindings && ts.isNamedImports(namedBindings)) {
+        if (namedBindings && ts2.isNamedImports(namedBindings)) {
           namedBindings.elements.forEach((element) => {
             bindings.add(element.name.text);
           });
@@ -32810,10 +32945,10 @@ function extractScriptBindings(scriptContent) {
       }
     };
     var extractNames = extractNames2, visit = visit2;
-    const sourceFile = ts.createSourceFile(
+    const sourceFile = ts2.createSourceFile(
       "temp.ts",
       scriptContent,
-      ts.ScriptTarget.Latest,
+      ts2.ScriptTarget.Latest,
       true
     );
     sourceFile.statements.forEach(visit2);
@@ -32825,9 +32960,9 @@ function extractScriptBindings(scriptContent) {
 function checkScriptFunctionCalls(scriptContent, bindings, violations) {
   try {
     let visit2 = function(node) {
-      if (ts.isCallExpression(node)) {
+      if (ts2.isCallExpression(node)) {
         const callee = node.expression;
-        if (ts.isIdentifier(callee)) {
+        if (ts2.isIdentifier(callee)) {
           const funcName = callee.text;
           const isHookCall = funcName.startsWith("use") && funcName.length > 3 && funcName[3] === funcName[3].toUpperCase();
           if (isHookCall) {
@@ -32841,16 +32976,16 @@ function checkScriptFunctionCalls(scriptContent, bindings, violations) {
           }
         }
       }
-      ts.forEachChild(node, visit2);
+      ts2.forEachChild(node, visit2);
     };
     var visit = visit2;
-    const sourceFile = ts.createSourceFile(
+    const sourceFile = ts2.createSourceFile(
       "temp.ts",
       scriptContent,
-      ts.ScriptTarget.Latest,
+      ts2.ScriptTarget.Latest,
       true
     );
-    ts.forEachChild(sourceFile, visit2);
+    ts2.forEachChild(sourceFile, visit2);
   } catch (err) {
   }
 }
@@ -32963,7 +33098,7 @@ function extractIdentifiersFromExpression(expression) {
     }
   }
   const cleanExpr = expression.replace(/'[^']*'/g, "").replace(/"[^"]*"/g, "").replace(/`[^`]*`/g, "");
-  const idRegex = /(?:^|[^.\w$])([a-zA-Z_$][\w$]*)\b(?!\s*:)/g;
+  const idRegex = /(?:^|[^.\w$])([a-zA-Z_$][\w$]*)(?![\w$])(?!\s*:)/g;
   let match;
   while ((match = idRegex.exec(cleanExpr)) !== null) {
     const id = match[1];
@@ -32980,6 +33115,7 @@ function isJsKeyword(id) {
   return JS_KEYWORDS.has(id);
 }
 function resolveExpectedImportSource(metadata) {
+  if (metadata.importSource) return metadata.importSource;
   const importStatement = metadata.importStatement || "";
   if (importStatement.includes("@ksyun-internal/versatile")) {
     return "@ksyun-internal/versatile";
@@ -32989,11 +33125,11 @@ function resolveExpectedImportSource(metadata) {
   }
   return null;
 }
-function checkImport(node, violations, sourceFile) {
+function checkImport(node, violations, sourceFile, componentImportContext) {
   const moduleSpecifier = node.moduleSpecifier.getText(sourceFile).replace(/['\"]/g, "");
   if (moduleSpecifier === "@king-design/vue" || moduleSpecifier === "@ksyun-internal/versatile") {
     const namedBindings = node.importClause?.namedBindings;
-    if (namedBindings && ts.isNamedImports(namedBindings)) {
+    if (namedBindings && ts2.isNamedImports(namedBindings)) {
       namedBindings.elements.forEach((element) => {
         const originalName = element.propertyName ? element.propertyName.text : element.name.text;
         const localName = element.name.text;
@@ -33025,14 +33161,16 @@ function checkImport(node, violations, sourceFile) {
           }
           return;
         }
-        if (isAlias) {
+        componentImportContext.set(localName, moduleSpecifier);
+        const metadata = componentRegistry.getComponent(originalName, moduleSpecifier);
+        const packageExport = packageExportRegistry.getExport(originalName, moduleSpecifier);
+        if (isAlias && (metadata || packageExport?.kind === "component")) {
           violations.push({
             rule: `\u7981\u6B62\u5BF9\u7EC4\u4EF6 ${originalName} \u4F7F\u7528\u522B\u540D\u5BFC\u5165`,
             match: `${originalName} as ${localName}`,
             suggestion: `\u76F4\u63A5\u4F7F\u7528\u539F\u540D: import { ${originalName} } from '${moduleSpecifier}'`
           });
         }
-        const metadata = componentRegistry.getComponent(originalName);
         if (metadata) {
           const expectedPackage = resolveExpectedImportSource(metadata);
           if (expectedPackage && expectedPackage !== moduleSpecifier) {
@@ -33043,11 +33181,24 @@ function checkImport(node, violations, sourceFile) {
             });
           }
         } else {
-          violations.push({
-            rule: "\u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684\u7EC4\u4EF6/\u5BFC\u51FA",
-            match: originalName,
-            suggestion: `\u8BF7\u786E\u8BA4 ${originalName} \u662F\u5426\u5B58\u5728\u4E8E ${moduleSpecifier}\u3002\u5EFA\u8BAE\u67E5\u770B\u6587\u6863\u3002`
-          });
+          if (packageExport) {
+            return;
+          }
+          const knownMetadata = componentRegistry.getComponent(originalName);
+          if (knownMetadata) {
+            const expectedPackage = resolveExpectedImportSource(knownMetadata);
+            violations.push({
+              rule: `\u7EC4\u4EF6 ${originalName} \u5BFC\u5165\u6E90\u9519\u8BEF`,
+              match: `import { ... } from '${moduleSpecifier}'`,
+              suggestion: expectedPackage ? `\u5E94\u4ECE '${expectedPackage}' \u5BFC\u5165` : `\u8BF7\u786E\u8BA4 ${originalName} \u7684\u5BFC\u5165\u6765\u6E90`
+            });
+          } else {
+            violations.push({
+              rule: "\u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684\u7EC4\u4EF6/\u5BFC\u51FA",
+              match: originalName,
+              suggestion: `\u8BF7\u786E\u8BA4 ${originalName} \u662F\u5426\u5B58\u5728\u4E8E ${moduleSpecifier}\u3002\u5EFA\u8BAE\u67E5\u770B\u6587\u6863\u3002`
+            });
+          }
         }
       });
     }
@@ -33296,14 +33447,16 @@ function checkEvents(tagName, node, metadata, violations) {
 function kebabTagToPascalTag(tag) {
   return tag.split("-").map((part) => part.length ? part.charAt(0).toUpperCase() + part.slice(1).toLowerCase() : "").join("");
 }
-function resolveRegisteredComponent(tag) {
-  if (componentRegistry.isKnownComponent(tag)) {
-    return componentRegistry.getComponent(tag);
+function resolveRegisteredComponent(tag, componentImportContext) {
+  const directImportSource = componentImportContext?.get(tag);
+  if (componentRegistry.isKnownComponent(tag, directImportSource)) {
+    return componentRegistry.getComponent(tag, directImportSource);
   }
   if (tag.includes("-")) {
     const pascal = kebabTagToPascalTag(tag);
-    if (componentRegistry.isKnownComponent(pascal)) {
-      return componentRegistry.getComponent(pascal);
+    const pascalImportSource = componentImportContext?.get(pascal);
+    if (componentRegistry.isKnownComponent(pascal, pascalImportSource)) {
+      return componentRegistry.getComponent(pascal, pascalImportSource);
     }
   }
   return void 0;
@@ -33350,11 +33503,11 @@ function checkSlots(tagName, node, metadata, violations) {
     });
   }
 }
-function checkTemplate(node, violations, ancestors) {
+function checkTemplate(node, violations, ancestors, componentImportContext) {
   if (node.type === 1) {
     const elementNode = node;
     const tagName = elementNode.tag;
-    const metadata = resolveRegisteredComponent(tagName);
+    const metadata = resolveRegisteredComponent(tagName, componentImportContext);
     const displayTag = metadata?.name ?? tagName;
     if (metadata) {
       checkNestingRules(displayTag, metadata, ancestors, violations);
@@ -33370,12 +33523,12 @@ function checkTemplate(node, violations, ancestors) {
     let newAncestors = ancestors;
     if (node.type === 1 && "tag" in node) {
       const el = node;
-      const meta = resolveRegisteredComponent(el.tag);
+      const meta = resolveRegisteredComponent(el.tag, componentImportContext);
       newAncestors = [...ancestors, meta?.name ?? el.tag];
     }
     node.children.forEach((child) => {
       if (typeof child === "object" && child !== null && "type" in child) {
-        checkTemplate(child, violations, newAncestors);
+        checkTemplate(child, violations, newAncestors, componentImportContext);
       }
     });
   }

package/dist/full/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkHARQRI4F_js = require('../chunk-HARQRI4F.js');
-require('../chunk-XPHDD6XR.js');
+var chunkGCHRZSCK_js = require('../chunk-GCHRZSCK.js');
+require('../chunk-4ZZ6E4RS.js');
 require('../chunk-V5N65MRP.js');
 require('../chunk-DHLWNT53.js');
 require('../chunk-KF5YBEM5.js');
@@ -11,9 +11,9 @@ require('../chunk-JSBRDJBE.js');
 
 Object.defineProperty(exports, "validateCode", {
   enumerable: true,
-  get: function () { return chunkHARQRI4F_js.validateCode; }
+  get: function () { return chunkGCHRZSCK_js.validateCode; }
 });
 Object.defineProperty(exports, "validateCodeSync", {
   enumerable: true,
-  get: function () { return chunkHARQRI4F_js.validateCodeSync; }
+  get: function () { return chunkGCHRZSCK_js.validateCodeSync; }
 });

package/dist/full/index.mjs

@@ -1,5 +1,5 @@
-export { validateCode, validateCodeSync } from '../chunk-BSCASJTV.mjs';
-import '../chunk-YRGYDK2I.mjs';
+export { validateCode, validateCodeSync } from '../chunk-SCECUJGJ.mjs';
+import '../chunk-ZW3HD2OD.mjs';
 import '../chunk-6HOIRUQB.mjs';
 import '../chunk-4OTQAQ6J.mjs';
 import '../chunk-QC6VTSA3.mjs';