king-design-analyzer 2.1.9 → 2.2.1

package/dist/chunk-DHLWNT53.js

@@ -0,0 +1,364 @@
+'use strict';
+
+var compilerSfc = require('@vue/compiler-sfc');
+var sucrase = require('sucrase');
+var ts = require('typescript');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+
+// src/tools/sfcCompiler.ts
+var ALLOWED_IMPORT_SOURCES = [
+  "vue",
+  "@vue/",
+  "vue-router",
+  "@king-design/vue",
+  "@ksyun-internal/versatile"
+];
+var VUE_RUNTIME_INJECTED_BINDINGS = /* @__PURE__ */ new Set([
+  "ref",
+  "reactive",
+  "computed",
+  "readonly",
+  "shallowRef",
+  "shallowReactive",
+  "toRef",
+  "toRefs",
+  "toRaw",
+  "markRaw",
+  "isRef",
+  "isReactive",
+  "isReadonly",
+  "isProxy",
+  "triggerRef",
+  "customRef",
+  "onMounted",
+  "onUnmounted",
+  "onBeforeMount",
+  "onBeforeUnmount",
+  "onUpdated",
+  "onBeforeUpdate",
+  "onActivated",
+  "onDeactivated",
+  "onErrorCaptured",
+  "watch",
+  "watchEffect",
+  "watchPostEffect",
+  "watchSyncEffect",
+  "defineProps",
+  "defineEmits",
+  "defineExpose",
+  "defineOptions",
+  "defineSlots",
+  "defineModel",
+  "withDefaults",
+  "useSlots",
+  "useAttrs",
+  "inject",
+  "provide",
+  "nextTick",
+  "getCurrentInstance",
+  "h",
+  "createVNode",
+  "resolveComponent"
+]);
+var VERSATILE_RUNTIME_INJECTED_BINDINGS = /* @__PURE__ */ new Set([
+  "useToState",
+  "useIdEntity"
+]);
+var INTERNAL_BINDING_PREFIXES = ["__imported_module_"];
+function getRuntimeInjectedBindingsForSource(source) {
+  if (source === "vue" || source.startsWith("@vue/")) {
+    return VUE_RUNTIME_INJECTED_BINDINGS;
+  }
+  if (source === "vue-router") {
+    return /* @__PURE__ */ new Set([
+      "useRouter",
+      "useRoute",
+      "onBeforeRouteLeave",
+      "onBeforeRouteUpdate",
+      "RouterLink",
+      "RouterView"
+    ]);
+  }
+  if (source === "@ksyun-internal/versatile") {
+    return VERSATILE_RUNTIME_INJECTED_BINDINGS;
+  }
+  return /* @__PURE__ */ new Set();
+}
+function normalizeNamedImportSpecifiers(specifiers) {
+  return specifiers.split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const aliasMatch = part.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
+    if (aliasMatch) {
+      return `${aliasMatch[1]}: ${aliasMatch[2]}`;
+    }
+    return part;
+  }).join(", ");
+}
+function shouldUseWhitelist(source, whitelist) {
+  return whitelist.some((allowedSource) => source === allowedSource || source.startsWith(`${allowedSource}/`));
+}
+function classifyImportSource(source, whitelist) {
+  if (shouldUseWhitelist(source, whitelist)) {
+    return "whitelisted";
+  }
+  if (source.startsWith(".")) {
+    return "relative";
+  }
+  return "unknown";
+}
+function scopeStyles(css, scopeClass) {
+  return css.replace(/([^\r\n,{}]+)(,(?=[^}]*{)|\s*{)/g, (match, selector, suffix) => {
+    if (selector.trim().startsWith("@")) return match;
+    const scopedSelector = selector.split(",").map((rawSelector) => {
+      const nextSelector = rawSelector.trim();
+      if (nextSelector === "body" || nextSelector === "html") return `.${scopeClass}`;
+      return `.${scopeClass} ${nextSelector}`;
+    }).join(", ");
+    return `${scopedSelector}${suffix}`;
+  });
+}
+function transformImportToBinding(importClause, sourceExpression) {
+  const trimmedClause = importClause.trim();
+  const namespaceMatch = trimmedClause.match(/^\*\s+as\s+(\w+)$/);
+  if (namespaceMatch) {
+    return `const ${namespaceMatch[1]} = ${sourceExpression};`;
+  }
+  const mixedMatch = trimmedClause.match(/^(\w+)\s*,\s*\{([^}]+)\}$/);
+  if (mixedMatch) {
+    const defaultName = mixedMatch[1];
+    const namedImports = normalizeNamedImportSpecifiers(mixedMatch[2]);
+    const moduleVar = `__imported_module_${defaultName}`;
+    return `const ${moduleVar} = ${sourceExpression}; const ${defaultName} = ${moduleVar}.default || ${moduleVar}; const { ${namedImports} } = ${moduleVar};`;
+  }
+  const defaultAndNamespaceMatch = trimmedClause.match(/^(\w+)\s*,\s*\*\s+as\s+(\w+)$/);
+  if (defaultAndNamespaceMatch) {
+    const defaultName = defaultAndNamespaceMatch[1];
+    const namespaceName = defaultAndNamespaceMatch[2];
+    const moduleVar = `__imported_module_${defaultName}`;
+    return `const ${moduleVar} = ${sourceExpression}; const ${defaultName} = ${moduleVar}.default || ${moduleVar}; const ${namespaceName} = ${moduleVar};`;
+  }
+  const namedMatch = trimmedClause.match(/^\{([^}]+)\}$/);
+  if (namedMatch) {
+    return `const { ${normalizeNamedImportSpecifiers(namedMatch[1])} } = ${sourceExpression};`;
+  }
+  const defaultMatch = trimmedClause.match(/^(\w+)$/);
+  if (defaultMatch) {
+    const defaultName = defaultMatch[1];
+    return `const ${defaultName} = ${sourceExpression}.default || ${sourceExpression};`;
+  }
+  return "";
+}
+function transformWhitelistedImport(importClause, source) {
+  const trimmedClause = importClause.trim();
+  const injectedBindings = getRuntimeInjectedBindingsForSource(source);
+  const buildNamedBinding = (specifiers, sourceExpression = `__getWhitelistedModule('${source}')`) => {
+    const namedBindings = specifiers.split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
+      const aliasMatch = part.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
+      if (aliasMatch) {
+        return `${aliasMatch[1]}: ${aliasMatch[2]}`;
+      }
+      return injectedBindings.has(part) ? null : part;
+    }).filter(Boolean);
+    if (namedBindings.length === 0) {
+      return "";
+    }
+    return `const { ${namedBindings.join(", ")} } = ${sourceExpression};`;
+  };
+  const namespaceMatch = trimmedClause.match(/^\*\s+as\s+(\w+)$/);
+  if (namespaceMatch) {
+    return `const ${namespaceMatch[1]} = __getWhitelistedModule('${source}');`;
+  }
+  const mixedMatch = trimmedClause.match(/^(\w+)\s*,\s*\{([^}]+)\}$/);
+  if (mixedMatch) {
+    const defaultName = mixedMatch[1];
+    const moduleVar = `__imported_module_${defaultName}`;
+    const parts = [
+      `const ${moduleVar} = __getWhitelistedModule('${source}');`,
+      `const ${defaultName} = ${moduleVar}.default || ${moduleVar};`
+    ];
+    const namedBinding = buildNamedBinding(mixedMatch[2], moduleVar);
+    if (namedBinding) {
+      parts.push(namedBinding);
+    }
+    return parts.join(" ");
+  }
+  const defaultAndNamespaceMatch = trimmedClause.match(/^(\w+)\s*,\s*\*\s+as\s+(\w+)$/);
+  if (defaultAndNamespaceMatch) {
+    const defaultName = defaultAndNamespaceMatch[1];
+    const namespaceName = defaultAndNamespaceMatch[2];
+    const moduleVar = `__imported_module_${defaultName}`;
+    return `const ${moduleVar} = __getWhitelistedModule('${source}'); const ${defaultName} = ${moduleVar}.default || ${moduleVar}; const ${namespaceName} = ${moduleVar};`;
+  }
+  const namedMatch = trimmedClause.match(/^\{([^}]+)\}$/);
+  if (namedMatch) {
+    return buildNamedBinding(namedMatch[1]);
+  }
+  const defaultMatch = trimmedClause.match(/^(\w+)$/);
+  if (defaultMatch) {
+    const defaultName = defaultMatch[1];
+    return `const ${defaultName} = __getWhitelistedModule('${source}').default || __getWhitelistedModule('${source}');`;
+  }
+  return "";
+}
+function collectRawScript(descriptor) {
+  return [descriptor.script?.content, descriptor.scriptSetup?.content].filter((block) => Boolean(block?.trim())).join("\n");
+}
+function transformValueImports(scriptContent, whitelist, strippedImports) {
+  let nextScript = scriptContent.replace(/import\s+type\s+[\s\S]*?from\s+['"].*?['"];?/g, "");
+  nextScript = nextScript.replace(
+    /import\s+([^;]+?)\s+from\s+['"]([^'"]+)['"];?/g,
+    (_match, importClause, source) => {
+      const reason = classifyImportSource(source, whitelist);
+      strippedImports.push({ source, reason });
+      if (reason === "whitelisted") {
+        return transformWhitelistedImport(importClause, source);
+      }
+      if (reason === "relative") {
+        return transformImportToBinding(importClause, `__mockModule('${source}')`);
+      }
+      return transformImportToBinding(importClause, `__mockModule('${source}')`);
+    }
+  );
+  nextScript = nextScript.replace(
+    /import\s+['"]([^'"]+)['"];?/g,
+    (_match, source) => {
+      const reason = classifyImportSource(source, whitelist);
+      strippedImports.push({ source, reason });
+      if (reason === "relative") {
+        return `__mockModule('${source}');`;
+      }
+      return `__mockModule('${source}');`;
+    }
+  );
+  return nextScript;
+}
+function stripExports(scriptContent) {
+  let nextScript = scriptContent;
+  nextScript = nextScript.replace(/export\s+default\s*\{[\s\S]*?\}\s*;?\s*$/g, "");
+  nextScript = nextScript.replace(/export\s+\{[\s\S]*?\}\s*;?/g, "");
+  nextScript = nextScript.replace(/export\s+default\s+/g, "");
+  nextScript = nextScript.replace(/export\s+(const|let|var|function|class|async\s+function)\s+/g, "$1 ");
+  return nextScript;
+}
+function transpileScript(scriptContent) {
+  const result = sucrase.transform(scriptContent, {
+    transforms: ["typescript"],
+    disableESTransforms: true
+  });
+  return result && typeof result.code === "string" ? result.code : scriptContent;
+}
+function extractBindingsFromScript(scriptContent) {
+  const bindings = /* @__PURE__ */ new Set();
+  try {
+    let extractNames2 = function(name) {
+      if (ts__namespace.isIdentifier(name)) {
+        bindings.add(name.text);
+        return;
+      }
+      if (ts__namespace.isObjectBindingPattern(name) || ts__namespace.isArrayBindingPattern(name)) {
+        name.elements.forEach((element) => {
+          if (ts__namespace.isBindingElement(element)) {
+            extractNames2(element.name);
+          }
+        });
+      }
+    }, visit2 = function(node) {
+      if (ts__namespace.isVariableStatement(node)) {
+        node.declarationList.declarations.forEach((decl) => extractNames2(decl.name));
+      } else if (ts__namespace.isFunctionDeclaration(node) && node.name) {
+        bindings.add(node.name.text);
+      } else if (ts__namespace.isClassDeclaration(node) && node.name) {
+        bindings.add(node.name.text);
+      }
+    };
+    var extractNames = extractNames2, visit = visit2;
+    const sourceFile = ts__namespace.createSourceFile(
+      "temp.ts",
+      scriptContent,
+      ts__namespace.ScriptTarget.Latest,
+      true
+    );
+    sourceFile.statements.forEach(visit2);
+  } catch {
+    return [];
+  }
+  return Array.from(bindings).filter(
+    (binding) => binding && /^[A-Za-z_$][\w$]*$/.test(binding) && !INTERNAL_BINDING_PREFIXES.some((prefix) => binding.startsWith(prefix))
+  );
+}
+function processExecutableScript(rawScript, whitelist, strippedImports) {
+  const withoutImports = transformValueImports(rawScript, whitelist, strippedImports);
+  const withoutExports = stripExports(withoutImports);
+  return transpileScript(withoutExports);
+}
+function getParseError(result) {
+  const firstError = result.errors[0];
+  if (!firstError) return void 0;
+  return typeof firstError === "string" ? firstError : firstError.message;
+}
+function compileSFC(code, scopeId, options) {
+  const whitelist = options?.allowedImports ?? ALLOWED_IMPORT_SOURCES;
+  const strippedImports = [];
+  try {
+    const parseResult = compilerSfc.parse(code, {
+      filename: "inline.vue",
+      sourceMap: false
+    });
+    const parseError = getParseError(parseResult);
+    if (parseError) {
+      return {
+        template: "",
+        script: "",
+        style: "",
+        bindings: [],
+        error: parseError
+      };
+    }
+    const { descriptor } = parseResult;
+    const template = descriptor.template?.content || "";
+    const rawScript = collectRawScript(descriptor);
+    const rawStyles = descriptor.styles.map((styleBlock) => styleBlock.content).join("\n");
+    const style = rawStyles ? scopeStyles(rawStyles, scopeId) : "";
+    if (!template && !rawScript) {
+      return { template: "", script: "", style: "", bindings: [] };
+    }
+    const executableScript = rawScript ? processExecutableScript(rawScript, whitelist, strippedImports) : "";
+    const bindings = executableScript ? extractBindingsFromScript(executableScript) : [];
+    return {
+      template,
+      script: executableScript,
+      style,
+      bindings,
+      strippedImports: strippedImports.length > 0 ? strippedImports : void 0
+    };
+  } catch (error) {
+    return {
+      template: "",
+      script: "",
+      style: "",
+      bindings: [],
+      error: error?.message || String(error)
+    };
+  }
+}
+
+exports.compileSFC = compileSFC;
+exports.scopeStyles = scopeStyles;

package/dist/{chunk-H2ET6MMM.mjs → chunk-IPJJMPOO.mjs}

@@ -1,8 +1,8 @@
+import { resolveMetadataInheritance, resolvePackageResourceDir } 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 { fileURLToPath } from 'url';
 import { parse } from '@vue/compiler-sfc';
 import * as ts from 'typescript';
 
@@ -32205,14 +32205,8 @@ var require_compiler_core = __commonJS({
     }
   }
 });
-var __filename$1 = fileURLToPath(import.meta.url);
-var __dirname$1 = path.dirname(__filename$1);
 function resolveComponentsPath() {
-  const prodPath = path.join(__dirname$1, "../components");
-  if (fsSync.existsSync(prodPath)) return prodPath;
-  const devPath = path.join(__dirname$1, "../../components");
-  if (fsSync.existsSync(devPath)) return devPath;
-  return prodPath;
+  return resolvePackageResourceDir("components");
 }
 var ComponentRegistry = class {
   constructor() {
@@ -32222,27 +32216,42 @@ var ComponentRegistry = class {
     // Path to components directory (resolved dynamically for dev/prod compatibility)
     this.metadataPath = resolveComponentsPath();
   }
-  async load() {
-    if (this.loaded) return;
-    await this.reload();
-    this.loaded = true;
-    this.startWatching();
+  async load(options = {}) {
+    if (!this.loaded) {
+      await this.reload();
+      this.loaded = true;
+    }
+    if (options.watch) {
+      this.startWatching();
+    }
   }
   /**
    * 重新加载所有组件元数据
    */
   async reload() {
     const newComponents = /* @__PURE__ */ new Map();
+    const rawComponents = {};
     try {
       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 data = JSON.parse(content);
-        newComponents.set(data.name, data);
-        if (data.subComponents) {
-          for (const sub of data.subComponents) {
-            newComponents.set(sub.name, sub);
+        rawComponents[data.name] = data;
+      }
+      for (const data of Object.values(rawComponents)) {
+        const resolvedData = resolveMetadataInheritance(data, rawComponents);
+        newComponents.set(resolvedData.name, resolvedData);
+        if (resolvedData.subComponents) {
+          for (const sub of resolvedData.subComponents) {
+            newComponents.set(sub.name, {
+              id: sub.name,
+              name: sub.name,
+              props: sub.props || [],
+              events: sub.events || [],
+              slots: sub.slots || [],
+              methods: sub.methods || []
+            });
           }
         }
       }
@@ -32298,14 +32307,8 @@ var componentRegistry = new ComponentRegistry();
 
 // src/analysis/astReviewer.ts
 var import_compiler_core = __toESM(require_compiler_core());
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
 function resolveHooksPath() {
-  const prodPath = path.join(__dirname2, "../hooks");
-  if (fsSync.existsSync(prodPath)) return prodPath;
-  const devPath = path.join(__dirname2, "../../hooks");
-  if (fsSync.existsSync(devPath)) return devPath;
-  return prodPath;
+  return resolvePackageResourceDir("hooks");
 }
 var HooksRegistry = class {
   constructor() {
@@ -32314,11 +32317,14 @@ var HooksRegistry = class {
     this.watcher = null;
     this.metadataPath = resolveHooksPath();
   }
-  async load() {
-    if (this.loaded) return;
-    await this.reload();
-    this.loaded = true;
-    this.startWatching();
+  async load(options = {}) {
+    if (!this.loaded) {
+      await this.reload();
+      this.loaded = true;
+    }
+    if (options.watch) {
+      this.startWatching();
+    }
   }
   /**
    * 重新加载所有 hooks 元数据
@@ -32721,24 +32727,10 @@ var STRICT_CHECK_ATTRIBUTES = /* @__PURE__ */ new Set([
   "checked",
   "selected"
 ]);
-var VERSATILE_COMPONENTS = /* @__PURE__ */ new Set([
-  "BillTypes",
-  "Region",
-  "AZ",
-  "LayoutContent",
-  "CardContent",
-  "ProTable",
-  "PaginationPlus",
-  "Status",
-  "TableColumnId",
-  "IconTooltip",
-  "ButtonLink"
-]);
 var NESTING_RULES = {
   "DropdownItem": ["DropdownMenu"],
   "DropdownMenu": ["Dropdown"],
   "TableColumn": ["Table", "ProTable"],
-  "FormItem": ["Form"],
   "Tab": ["Tabs"],
   "Step": ["Steps"],
   "MenuItem": ["Menu", "SubMenu"],
@@ -32987,6 +32979,16 @@ function isTemplateBuiltin(id) {
 function isJsKeyword(id) {
   return JS_KEYWORDS.has(id);
 }
+function resolveExpectedImportSource(metadata) {
+  const importStatement = metadata.importStatement || "";
+  if (importStatement.includes("@ksyun-internal/versatile")) {
+    return "@ksyun-internal/versatile";
+  }
+  if (importStatement.includes("@king-design/vue")) {
+    return "@king-design/vue";
+  }
+  return null;
+}
 function checkImport(node, violations, sourceFile) {
   const moduleSpecifier = node.moduleSpecifier.getText(sourceFile).replace(/['\"]/g, "");
   if (moduleSpecifier === "@king-design/vue" || moduleSpecifier === "@ksyun-internal/versatile") {
@@ -33030,10 +33032,10 @@ function checkImport(node, violations, sourceFile) {
             suggestion: `\u76F4\u63A5\u4F7F\u7528\u539F\u540D: import { ${originalName} } from '${moduleSpecifier}'`
           });
         }
-        if (componentRegistry.isKnownComponent(originalName)) {
-          const isVersatile = VERSATILE_COMPONENTS.has(originalName);
-          const expectedPackage = isVersatile ? "@ksyun-internal/versatile" : "@king-design/vue";
-          if (expectedPackage !== moduleSpecifier) {
+        const metadata = componentRegistry.getComponent(originalName);
+        if (metadata) {
+          const expectedPackage = resolveExpectedImportSource(metadata);
+          if (expectedPackage && expectedPackage !== moduleSpecifier) {
             violations.push({
               rule: `\u7EC4\u4EF6 ${originalName} \u5BFC\u5165\u6E90\u9519\u8BEF`,
               match: `import { ... } from '${moduleSpecifier}'`,
@@ -33065,7 +33067,7 @@ function checkNestingRules(tagName, metadata, ancestors, violations) {
     });
   }
 }
-function checkComponentSpecificRules(tagName, node, violations) {
+function checkComponentSpecificRules(tagName, node, metadata, violations) {
   if (tagName === "Dropdown") {
     node.children?.forEach((child) => {
       if (child.type === 1 && child.tag === "template") {
@@ -33104,23 +33106,110 @@ function checkComponentSpecificRules(tagName, node, violations) {
       }
     });
   }
-  if (tagName === "TableColumn") {
-    node.children?.forEach((child) => {
-      if (child.type === 1 && child.tag === "template") {
-        const slotProp = child.props?.find((p) => p.type === 7 && p.name === "slot");
-        if (slotProp && slotProp.exp && slotProp.exp.content) {
-          const exp = slotProp.exp.content.trim();
-          if (exp.startsWith("{") && exp.endsWith("}")) {
-            violations.push({
-              rule: "TableColumn \u63D2\u69FD\u53C2\u6570\u5E94\u4E3A\u6570\u7EC4\u7ED3\u6784",
-              match: exp,
-              suggestion: `King Design \u8868\u683C\u63D2\u69FD\u53C2\u6570\u4E3A\u6570\u7EC4\u987A\u5E8F\u4F20\u9012\uFF0C\u8BF7\u5C06 ${exp} \u6539\u4E3A [row]`
-            });
-          }
-        }
-      }
-    });
+  if (!metadata?.slots?.length) {
+    return;
+  }
+  const validateSlotBinding = (slotName, expression) => {
+    if (!expression) return;
+    const slot = metadata.slots.find((item) => item.name === slotName);
+    if (!slot) return;
+    const exp = expression.trim();
+    const bindingType = resolveSlotBindingType(slot);
+    if (!bindingType) return;
+    if (bindingType === "none") {
+      violations.push({
+        rule: `${tagName} \u63D2\u69FD #${slotName} \u4E0D\u63D0\u4F9B\u53C2\u6570`,
+        match: exp,
+        suggestion: `\u8BF7\u79FB\u9664 ${slotName} \u63D2\u69FD\u4E0A\u7684\u53C2\u6570\u58F0\u660E`
+      });
+      return;
+    }
+    if (bindingType === "array" && isObjectDestructuringExpression(exp)) {
+      violations.push({
+        rule: `${tagName} \u63D2\u69FD\u53C2\u6570\u5E94\u4E3A\u6570\u7EC4\u7ED3\u6784`,
+        match: exp,
+        suggestion: `\u8BF7\u5C06 ${exp} \u6539\u4E3A ${getSlotBindingExample(slot, "array")}`
+      });
+      return;
+    }
+    if (bindingType === "object" && isArrayDestructuringExpression(exp)) {
+      violations.push({
+        rule: `${tagName} \u63D2\u69FD\u53C2\u6570\u5E94\u4E3A\u5BF9\u8C61\u7ED3\u6784`,
+        match: exp,
+        suggestion: `\u8BF7\u5C06 ${exp} \u6539\u4E3A ${getSlotBindingExample(slot, "object")}`
+      });
+      return;
+    }
+    if (bindingType === "single" && (isArrayDestructuringExpression(exp) || isObjectDestructuringExpression(exp))) {
+      violations.push({
+        rule: `${tagName} \u63D2\u69FD\u53C2\u6570\u5E94\u4E3A\u5355\u503C\u7ED3\u6784`,
+        match: exp,
+        suggestion: `\u8BF7\u5C06 ${exp} \u6539\u4E3A ${getSlotBindingExample(slot, "single")}`
+      });
+    }
+  };
+  node.props.forEach((prop) => {
+    if (prop.type !== 7 || prop.name !== "slot") return;
+    validateSlotBinding(slotNameFromVSlotDirective(prop), getDirectiveExpressionContent(prop.exp));
+  });
+  node.children?.forEach((child) => {
+    if (child.type !== 1 || child.tag !== "template") return;
+    const slotProp = child.props?.find((p) => p.type === 7 && p.name === "slot");
+    if (!slotProp) return;
+    validateSlotBinding(slotNameFromVSlotDirective(slotProp), getDirectiveExpressionContent(slotProp.exp));
+  });
+}
+function isArrayDestructuringExpression(expression) {
+  return expression.startsWith("[") && expression.endsWith("]");
+}
+function isObjectDestructuringExpression(expression) {
+  return expression.startsWith("{") && expression.endsWith("}");
+}
+function extractBindingExpressionFromVueTemplate(vueTemplate) {
+  if (!vueTemplate) return void 0;
+  const match = vueTemplate.match(/=\s*"([^"]+)"/);
+  return match?.[1]?.trim();
+}
+function getDirectiveExpressionContent(exp) {
+  if (!exp || !("content" in exp)) return void 0;
+  return typeof exp.content === "string" ? exp.content : void 0;
+}
+function resolveSlotBindingType(slot) {
+  if (slot.bindingType) {
+    return slot.bindingType;
+  }
+  const templateExpression = extractBindingExpressionFromVueTemplate(slot.vueTemplate);
+  if (templateExpression) {
+    if (isArrayDestructuringExpression(templateExpression)) return "array";
+    if (isObjectDestructuringExpression(templateExpression)) return "object";
+  }
+  const destructuringExample = slot.slotProps?.find((prop) => prop.destructuringExample)?.destructuringExample?.trim();
+  if (destructuringExample) {
+    if (isArrayDestructuringExpression(destructuringExample)) return "array";
+    if (isObjectDestructuringExpression(destructuringExample)) return "object";
+  }
+  return void 0;
+}
+function getSlotBindingExample(slot, fallbackType) {
+  const templateExpression = extractBindingExpressionFromVueTemplate(slot.vueTemplate);
+  if (templateExpression) {
+    return templateExpression;
+  }
+  const destructuringExample = slot.slotProps?.find((prop) => prop.destructuringExample)?.destructuringExample?.trim();
+  if (destructuringExample) {
+    return destructuringExample;
+  }
+  const paramNames = slot.slotProps?.map((prop) => prop.name).filter(Boolean) || [];
+  if (paramNames.length > 0) {
+    if (fallbackType === "single") {
+      return paramNames[0];
+    }
+    return fallbackType === "array" ? `[${paramNames.join(", ")}]` : `{ ${paramNames.join(", ")} }`;
+  }
+  if (fallbackType === "single") {
+    return "slotProp";
   }
+  return fallbackType === "array" ? "[slotProps]" : "{ slotProps }";
 }
 function typeRawAllowsNumber(typeRaw) {
   if (!typeRaw) return false;
@@ -33211,7 +33300,7 @@ function checkEvents(tagName, node, metadata, violations) {
       (e) => e.name === eventName || e.name === camelCaseEvent || e.name.toLowerCase() === eventName.toLowerCase()
     );
     const isNativeEvent = NATIVE_EVENTS.has(eventName);
-    if (!isEventValid && !isNativeEvent && metadata.events && metadata.events.length > 0) {
+    if (!isEventValid && !isNativeEvent) {
       violations.push({
         rule: `\u4E8B\u4EF6 @${eventName} \u4E0D\u5B58\u5728\u4E8E ${tagName}`,
         match: `@${eventName}`,
@@ -33286,7 +33375,7 @@ function checkTemplate(node, violations, ancestors) {
     if (metadata) {
       checkNestingRules(displayTag, metadata, ancestors, violations);
     }
-    checkComponentSpecificRules(displayTag, elementNode, violations);
+    checkComponentSpecificRules(displayTag, elementNode, metadata, violations);
     if (metadata) {
       checkProps(displayTag, elementNode, metadata, violations);
       checkEvents(displayTag, elementNode, metadata, violations);