king-design-analyzer 2.2.2 → 2.2.4

package/dist/{chunk-XPHDD6XR.js → chunk-4ZZ6E4RS.js}

@@ -3,10 +3,10 @@
 var chunkKF5YBEM5_js = require('./chunk-KF5YBEM5.js');
 var chunkJSBRDJBE_js = require('./chunk-JSBRDJBE.js');
 var fs = require('fs/promises');
-var fsSync = require('fs');
-var path = require('path');
+var fs3 = require('fs');
+var path3 = require('path');
 var compilerSfc = require('@vue/compiler-sfc');
-var ts = require('typescript');
+var ts2 = require('typescript');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -27,9 +27,9 @@ function _interopNamespace(e) {
 }
 
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var fsSync__namespace = /*#__PURE__*/_interopNamespace(fsSync);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+var ts2__namespace = /*#__PURE__*/_interopNamespace(ts2);
 
 // node_modules/@vue/shared/dist/shared.cjs.prod.js
 var require_shared_cjs_prod = chunkJSBRDJBE_js.__commonJS({
@@ -16831,27 +16831,27 @@ var require_util = chunkJSBRDJBE_js.__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++;
           }
         }
@@ -16872,18 +16872,18 @@ var require_util = chunkJSBRDJBE_js.__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 = ".";
       }
@@ -16915,7 +16915,7 @@ var require_util = chunkJSBRDJBE_js.__commonJS({
       }
       return joined;
     }
-    exports$1.join = join3;
+    exports$1.join = join4;
     exports$1.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -17129,7 +17129,7 @@ var require_util = chunkJSBRDJBE_js.__commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join3(urlGenerate(parsed), sourceURL);
+        sourceURL = join4(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -20517,14 +20517,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 === "[") {
@@ -20560,7 +20560,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) {
@@ -27287,14 +27287,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 === "[") {
@@ -27330,7 +27330,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) {
@@ -32233,6 +32233,11 @@ var require_compiler_core = chunkJSBRDJBE_js.__commonJS({
 function resolveComponentsPath() {
   return chunkKF5YBEM5_js.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();
@@ -32260,18 +32265,27 @@ var ComponentRegistry = class {
       const files = await fs__namespace.readdir(this.metadataPath);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const content = await fs__namespace.readFile(path__namespace.join(this.metadataPath, file), "utf-8");
+        const content = await fs__namespace.readFile(path3__namespace.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 = chunkKF5YBEM5_js.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 || [],
@@ -32281,11 +32295,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);
+  }
   /**
    * 开始监听文件变化
    */
@@ -32293,7 +32313,7 @@ var ComponentRegistry = class {
     if (this.watcher) return;
     try {
       let reloadTimeout = null;
-      this.watcher = fsSync__namespace.watch(this.metadataPath, (eventType, filename) => {
+      this.watcher = fs3__namespace.watch(this.metadataPath, (eventType, filename) => {
         if (!filename?.endsWith(".json")) return;
         console.log(`[ComponentRegistry] Detected change: ${filename} (${eventType})`);
         if (reloadTimeout) {
@@ -32318,14 +32338,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();
@@ -32360,7 +32394,7 @@ var HooksRegistry = class {
       const files = await fs__namespace.readdir(this.metadataPath);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const content = await fs__namespace.readFile(path__namespace.join(this.metadataPath, file), "utf-8");
+        const content = await fs__namespace.readFile(path3__namespace.join(this.metadataPath, file), "utf-8");
         const data = JSON.parse(content);
         newHooks.set(data.name, data);
       }
@@ -32381,7 +32415,7 @@ var HooksRegistry = class {
     if (this.watcher) return;
     try {
       let reloadTimeout = null;
-      this.watcher = fsSync__namespace.watch(this.metadataPath, (eventType, filename) => {
+      this.watcher = fs3__namespace.watch(this.metadataPath, (eventType, filename) => {
         if (!filename?.endsWith(".json")) return;
         console.log(`[HooksRegistry] Detected change: ${filename} (${eventType})`);
         if (reloadTimeout) {
@@ -32430,6 +32464,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 = chunkKF5YBEM5_js.resolvePackageRoot();
+  const segments = packagePathSegments(moduleSpecifier);
+  const cwd = process.cwd();
+  const candidates = [
+    path3__namespace.join(cwd, "node_modules", ...segments),
+    path3__namespace.join(cwd, "web", "node_modules", ...segments),
+    packageRoot ? path3__namespace.join(packageRoot, "node_modules", ...segments) : null,
+    packageRoot ? path3__namespace.join(packageRoot, "web", "node_modules", ...segments) : null
+  ].filter((candidate) => Boolean(candidate));
+  return candidates.find((candidate) => fs3__namespace.existsSync(candidate)) || null;
+}
+function resolvePackageTypesEntry(moduleSpecifier) {
+  const packageDir = resolveInstalledPackageDir(moduleSpecifier);
+  if (!packageDir) return null;
+  const packageJsonPath = path3__namespace.join(packageDir, "package.json");
+  if (fs3__namespace.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs3__namespace.readFileSync(packageJsonPath, "utf-8"));
+      const declaredEntry = packageJson.types || packageJson.typings;
+      if (declaredEntry) {
+        const resolved = path3__namespace.join(packageDir, declaredEntry);
+        if (fs3__namespace.existsSync(resolved)) {
+          return resolved;
+        }
+      }
+    } catch {
+    }
+  }
+  const fallbackEntry = path3__namespace.join(packageDir, "index.d.ts");
+  return fs3__namespace.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__namespace.createProgram([entry], {
+      target: ts2__namespace.ScriptTarget.ES2020,
+      module: ts2__namespace.ModuleKind.ESNext,
+      moduleResolution: ts2__namespace.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([
@@ -32768,27 +32900,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 } = compilerSfc.parse(code);
   if (errors.length > 0) {
     return violations;
   }
   const scriptContent = descriptor.scriptSetup?.content || descriptor.script?.content || "";
   if (scriptContent) {
-    const sourceFile = ts__namespace.createSourceFile(
+    const sourceFile = ts2__namespace.createSourceFile(
       "temp.ts",
       scriptContent,
-      ts__namespace.ScriptTarget.Latest,
+      ts2__namespace.ScriptTarget.Latest,
       true
     );
-    ts__namespace.forEachChild(sourceFile, (node) => {
-      if (ts__namespace.isImportDeclaration(node)) {
-        checkImport(node, violations, sourceFile);
+    ts2__namespace.forEachChild(sourceFile, (node) => {
+      if (ts2__namespace.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);
@@ -32806,25 +32941,25 @@ function extractScriptBindings(scriptContent) {
   JS_GLOBALS.forEach((b) => bindings.add(b));
   try {
     let extractNames2 = function(name) {
-      if (ts__namespace.isIdentifier(name)) {
+      if (ts2__namespace.isIdentifier(name)) {
         bindings.add(name.text);
-      } else if (ts__namespace.isObjectBindingPattern(name) || ts__namespace.isArrayBindingPattern(name)) {
+      } else if (ts2__namespace.isObjectBindingPattern(name) || ts2__namespace.isArrayBindingPattern(name)) {
         name.elements.forEach((element) => {
-          if (ts__namespace.isBindingElement(element)) {
+          if (ts2__namespace.isBindingElement(element)) {
             extractNames2(element.name);
           }
         });
       }
     }, visit2 = function(node) {
-      if (ts__namespace.isVariableStatement(node)) {
+      if (ts2__namespace.isVariableStatement(node)) {
         node.declarationList.declarations.forEach((decl) => extractNames2(decl.name));
-      } else if (ts__namespace.isFunctionDeclaration(node) && node.name) {
+      } else if (ts2__namespace.isFunctionDeclaration(node) && node.name) {
         bindings.add(node.name.text);
-      } else if (ts__namespace.isClassDeclaration(node) && node.name) {
+      } else if (ts2__namespace.isClassDeclaration(node) && node.name) {
         bindings.add(node.name.text);
-      } else if (ts__namespace.isImportDeclaration(node)) {
+      } else if (ts2__namespace.isImportDeclaration(node)) {
         const namedBindings = node.importClause?.namedBindings;
-        if (namedBindings && ts__namespace.isNamedImports(namedBindings)) {
+        if (namedBindings && ts2__namespace.isNamedImports(namedBindings)) {
           namedBindings.elements.forEach((element) => {
             bindings.add(element.name.text);
           });
@@ -32835,10 +32970,10 @@ function extractScriptBindings(scriptContent) {
       }
     };
     var extractNames = extractNames2, visit = visit2;
-    const sourceFile = ts__namespace.createSourceFile(
+    const sourceFile = ts2__namespace.createSourceFile(
       "temp.ts",
       scriptContent,
-      ts__namespace.ScriptTarget.Latest,
+      ts2__namespace.ScriptTarget.Latest,
       true
     );
     sourceFile.statements.forEach(visit2);
@@ -32850,9 +32985,9 @@ function extractScriptBindings(scriptContent) {
 function checkScriptFunctionCalls(scriptContent, bindings, violations) {
   try {
     let visit2 = function(node) {
-      if (ts__namespace.isCallExpression(node)) {
+      if (ts2__namespace.isCallExpression(node)) {
         const callee = node.expression;
-        if (ts__namespace.isIdentifier(callee)) {
+        if (ts2__namespace.isIdentifier(callee)) {
           const funcName = callee.text;
           const isHookCall = funcName.startsWith("use") && funcName.length > 3 && funcName[3] === funcName[3].toUpperCase();
           if (isHookCall) {
@@ -32866,16 +33001,16 @@ function checkScriptFunctionCalls(scriptContent, bindings, violations) {
           }
         }
       }
-      ts__namespace.forEachChild(node, visit2);
+      ts2__namespace.forEachChild(node, visit2);
     };
     var visit = visit2;
-    const sourceFile = ts__namespace.createSourceFile(
+    const sourceFile = ts2__namespace.createSourceFile(
       "temp.ts",
       scriptContent,
-      ts__namespace.ScriptTarget.Latest,
+      ts2__namespace.ScriptTarget.Latest,
       true
     );
-    ts__namespace.forEachChild(sourceFile, visit2);
+    ts2__namespace.forEachChild(sourceFile, visit2);
   } catch (err) {
   }
 }
@@ -32988,7 +33123,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];
@@ -33005,6 +33140,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";
@@ -33014,11 +33150,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__namespace.isNamedImports(namedBindings)) {
+    if (namedBindings && ts2__namespace.isNamedImports(namedBindings)) {
       namedBindings.elements.forEach((element) => {
         const originalName = element.propertyName ? element.propertyName.text : element.name.text;
         const localName = element.name.text;
@@ -33050,14 +33186,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) {
@@ -33068,11 +33206,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`
+            });
+          }
         }
       });
     }
@@ -33321,14 +33472,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;
@@ -33375,11 +33528,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);
@@ -33395,12 +33548,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/{chunk-HARQRI4F.js → chunk-GCHRZSCK.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkXPHDD6XR_js = require('./chunk-XPHDD6XR.js');
+var chunk4ZZ6E4RS_js = require('./chunk-4ZZ6E4RS.js');
 var chunkV5N65MRP_js = require('./chunk-V5N65MRP.js');
 var chunkDHLWNT53_js = require('./chunk-DHLWNT53.js');
 
@@ -64,7 +64,7 @@ function validateCompilation(code) {
 }
 async function validateAST(code) {
   try {
-    const violations = await chunkXPHDD6XR_js.analyzeCodeWithAST(code);
+    const violations = await chunk4ZZ6E4RS_js.analyzeCodeWithAST(code);
     if (violations.length > 0) {
       return {
         name: "AST\u89C4\u5219\u68C0\u67E5",

package/dist/{chunk-BSCASJTV.mjs → chunk-SCECUJGJ.mjs}

@@ -1,4 +1,4 @@
-import { analyzeCodeWithAST } from './chunk-YRGYDK2I.mjs';
+import { analyzeCodeWithAST } from './chunk-ZW3HD2OD.mjs';
 import { validateRuntimePrecheck } from './chunk-6HOIRUQB.mjs';
 import { compileSFC } from './chunk-4OTQAQ6J.mjs';