king-design-analyzer 2.2.0 → 2.2.2

package/dist/chunk-V5N65MRP.js

@@ -0,0 +1,411 @@
+'use strict';
+
+var chunkDHLWNT53_js = require('./chunk-DHLWNT53.js');
+
+// src/runtime/index.ts
+var scopeIdCounter = 0;
+var ENVIRONMENT_SENSITIVE_IDENTIFIERS = [
+  "window",
+  "document",
+  "location",
+  "navigator"
+];
+var ENVIRONMENT_SENSITIVE_CALLS = [
+  "getCurrentInstance",
+  "useRouter",
+  "useRoute",
+  "onBeforeRouteLeave",
+  "onBeforeRouteUpdate"
+];
+function createMockProxy(path) {
+  const target = function mockTarget() {
+  };
+  return new Proxy(target, {
+    get: (_target, prop, receiver) => {
+      const existing = Reflect.get(target, prop, receiver);
+      if (existing !== void 0) return existing;
+      if (prop === Symbol.toPrimitive) return () => 0;
+      if (prop === "then") return void 0;
+      if (prop === "toString") return () => `[MockProxy ${path}]`;
+      if (prop === "valueOf") return () => 0;
+      if (prop === "__path") return path;
+      return createMockProxy(`${path}.${String(prop)}`);
+    },
+    apply: () => createMockProxy(`${path}()`),
+    construct: () => createMockProxy(`new ${path}()`),
+    has: (_target, prop) => Reflect.has(target, prop),
+    set: (_target, prop, value, receiver) => Reflect.set(target, prop, value, receiver)
+  });
+}
+function createWhitelistedModule(source, context) {
+  if (source === "vue" || source.startsWith("@vue/")) {
+    return context;
+  }
+  if (source === "vue-router") {
+    return context.__mockVueRouter;
+  }
+  return new Proxy({}, {
+    get: (_target, prop) => {
+      if (prop === "default") return createMockProxy(source);
+      if (typeof prop === "string" && prop in context) {
+        return context[prop];
+      }
+      return createMockProxy(`${source}.${String(prop)}`);
+    }
+  });
+}
+function createMockElement(path) {
+  const element = createMockProxy(path);
+  element.style = {};
+  element.classList = {
+    add: () => {
+    },
+    remove: () => {
+    },
+    contains: () => false
+  };
+  element.dataset = {};
+  element.getBoundingClientRect = () => ({
+    x: 0,
+    y: 0,
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    width: 0,
+    height: 0
+  });
+  return element;
+}
+var MOCK_LOCATION = {
+  href: "https://mock.local/",
+  pathname: "/",
+  search: "",
+  hash: "",
+  origin: "https://mock.local",
+  host: "mock.local",
+  hostname: "mock.local",
+  port: "",
+  protocol: "https:",
+  assign: () => {
+  },
+  replace: () => {
+  },
+  reload: () => {
+  }
+};
+var MOCK_NAVIGATOR = {
+  userAgent: "king-design-analyzer-runtime-mock",
+  language: "zh-CN",
+  languages: ["zh-CN"],
+  clipboard: {
+    writeText: async () => {
+    },
+    readText: async () => ""
+  }
+};
+var MOCK_DOCUMENT = {
+  body: createMockElement("document.body"),
+  head: createMockElement("document.head"),
+  documentElement: createMockElement("document.documentElement"),
+  createElement: (_tag) => createMockElement("document.createElement()"),
+  createTextNode: (_text) => createMockElement("document.createTextNode()"),
+  getElementById: (_id) => createMockElement("document.getElementById()"),
+  querySelector: (_selector) => createMockElement("document.querySelector()"),
+  querySelectorAll: () => [],
+  addEventListener: () => {
+  },
+  removeEventListener: () => {
+  }
+};
+var MOCK_WINDOW = {
+  document: MOCK_DOCUMENT,
+  navigator: MOCK_NAVIGATOR,
+  location: MOCK_LOCATION,
+  innerWidth: 1440,
+  innerHeight: 900,
+  addEventListener: () => {
+  },
+  removeEventListener: () => {
+  },
+  matchMedia: () => ({
+    matches: false,
+    media: "",
+    onchange: null,
+    addListener: () => {
+    },
+    removeListener: () => {
+    },
+    addEventListener: () => {
+    },
+    removeEventListener: () => {
+    },
+    dispatchEvent: () => false
+  }),
+  requestAnimationFrame: (cb) => {
+    cb(0);
+    return 0;
+  },
+  cancelAnimationFrame: () => {
+  },
+  setTimeout,
+  clearTimeout,
+  setInterval,
+  clearInterval,
+  open: () => createMockProxy("window.open()")
+};
+var MOCK_ROUTE = {
+  path: "/",
+  name: void 0,
+  fullPath: "/",
+  params: {},
+  query: {},
+  hash: "",
+  meta: {},
+  matched: []
+};
+var MOCK_ROUTER = {
+  currentRoute: { value: MOCK_ROUTE },
+  push: async () => void 0,
+  replace: async () => void 0,
+  back: () => {
+  },
+  go: () => {
+  },
+  forward: () => {
+  },
+  beforeEach: () => () => {
+  },
+  afterEach: () => () => {
+  }
+};
+function detectEnvironmentSensitivity(code, strippedImports = []) {
+  const warnings = [];
+  let status = "passed";
+  for (const identifier of ENVIRONMENT_SENSITIVE_IDENTIFIERS) {
+    if (new RegExp(`\\b${identifier}\\b`).test(code)) {
+      warnings.push(`\u68C0\u6D4B\u5230\u6D4F\u89C8\u5668\u73AF\u5883\u5BF9\u8C61 ${identifier}\uFF0C\u8FD0\u884C\u65F6\u7ED3\u679C\u4F9D\u8D56\u5BBF\u4E3B\u73AF\u5883 mock\u3002`);
+      status = "env_dependent";
+    }
+  }
+  for (const callee of ENVIRONMENT_SENSITIVE_CALLS) {
+    if (new RegExp(`\\b${callee}\\s*\\(`).test(code)) {
+      warnings.push(`\u68C0\u6D4B\u5230\u73AF\u5883\u654F\u611F\u8C03\u7528 ${callee}()\uFF0C\u8FD0\u884C\u65F6\u7ED3\u679C\u4F9D\u8D56 mock\u3002`);
+      status = "env_dependent";
+    }
+  }
+  const skippedImports = strippedImports.filter(
+    (item) => item.reason === "unknown" && !item.source.startsWith(".")
+  );
+  if (skippedImports.length > 0) {
+    status = "runtime_skipped";
+    warnings.push(
+      `\u68C0\u6D4B\u5230\u7B2C\u4E09\u65B9\u5BFC\u5165 ${skippedImports.map((item) => item.source).join(", ")}\uFF0C\u5DF2\u4F7F\u7528\u6A21\u5757 mock\uFF0C\u8FD0\u884C\u65F6\u7ED3\u679C\u4EC5\u4F9B\u53C2\u8003\u3002`
+    );
+  }
+  return { status, warnings };
+}
+function isEnvironmentRelatedRuntimeError(message) {
+  return /(window|document|location|navigator|getCurrentInstance|useRouter|useRoute|route|router)/i.test(message);
+}
+var MOCK_VUE_CONTEXT = {
+  // Reactivity
+  ref: (v) => ({ value: v }),
+  reactive: (v) => v,
+  computed: (fn) => ({ value: typeof fn === "function" ? fn() : fn }),
+  readonly: (v) => v,
+  shallowRef: (v) => ({ value: v }),
+  shallowReactive: (v) => v,
+  toRef: () => ({ value: void 0 }),
+  toRefs: (obj) => Object.fromEntries(
+    Object.keys(obj || {}).map((k) => [k, { value: obj[k] }])
+  ),
+  toRaw: (v) => v,
+  markRaw: (v) => v,
+  isRef: () => false,
+  isReactive: () => false,
+  isReadonly: () => false,
+  isProxy: () => false,
+  triggerRef: () => {
+  },
+  customRef: (factory) => factory(() => {
+  }, () => {
+  }),
+  // Lifecycle
+  onMounted: () => {
+  },
+  onUnmounted: () => {
+  },
+  onBeforeMount: () => {
+  },
+  onBeforeUnmount: () => {
+  },
+  onUpdated: () => {
+  },
+  onBeforeUpdate: () => {
+  },
+  onActivated: () => {
+  },
+  onDeactivated: () => {
+  },
+  onErrorCaptured: () => {
+  },
+  // Watchers
+  watch: () => () => {
+  },
+  watchEffect: () => () => {
+  },
+  watchPostEffect: () => () => {
+  },
+  watchSyncEffect: () => () => {
+  },
+  // Composition API
+  defineProps: () => ({}),
+  defineEmits: () => () => {
+  },
+  defineExpose: () => {
+  },
+  defineOptions: () => {
+  },
+  defineSlots: () => ({}),
+  defineModel: () => ({ value: void 0 }),
+  withDefaults: (_props, defaults) => defaults,
+  useSlots: () => ({}),
+  useAttrs: () => ({}),
+  // Dependency Injection
+  inject: () => void 0,
+  provide: () => {
+  },
+  // Utilities
+  nextTick: () => Promise.resolve(),
+  getCurrentInstance: () => ({
+    proxy: createMockProxy("instance.proxy"),
+    appContext: createMockProxy("instance.appContext"),
+    emit: () => {
+    },
+    attrs: {},
+    slots: {}
+  }),
+  h: () => ({}),
+  createVNode: () => ({}),
+  resolveComponent: () => ({}),
+  // Browser-ish globals
+  window: MOCK_WINDOW,
+  document: MOCK_DOCUMENT,
+  location: MOCK_LOCATION,
+  navigator: MOCK_NAVIGATOR,
+  self: MOCK_WINDOW,
+  globalThis: MOCK_WINDOW,
+  // vue-router
+  useRouter: () => MOCK_ROUTER,
+  useRoute: () => MOCK_ROUTE,
+  onBeforeRouteLeave: () => {
+  },
+  onBeforeRouteUpdate: () => {
+  },
+  RouterLink: createMockProxy("vue-router.RouterLink"),
+  RouterView: createMockProxy("vue-router.RouterView"),
+  __mockVueRouter: {
+    useRouter: () => MOCK_ROUTER,
+    useRoute: () => MOCK_ROUTE,
+    onBeforeRouteLeave: () => {
+    },
+    onBeforeRouteUpdate: () => {
+    },
+    RouterLink: createMockProxy("vue-router.RouterLink"),
+    RouterView: createMockProxy("vue-router.RouterView"),
+    createRouter: () => createMockProxy("vue-router.createRouter()"),
+    createWebHistory: () => createMockProxy("vue-router.createWebHistory()"),
+    createWebHashHistory: () => createMockProxy("vue-router.createWebHashHistory()")
+  },
+  // =========================================================================
+  // @ksyun-internal/versatile Hooks
+  // =========================================================================
+  useToState: (_props, _key, _emit, defaultValue) => ({ value: defaultValue ?? void 0 }),
+  useIdEntity: () => ({ value: void 0 }),
+  // =========================================================================
+  // Module Mocking
+  // =========================================================================
+  __mockModule: (modulePath) => createMockProxy(modulePath),
+  __getWhitelistedModule: (source) => createWhitelistedModule(source, MOCK_VUE_CONTEXT)
+};
+function validateRuntimePrecheck(code) {
+  const scopeId = `runtime-${Date.now()}-${++scopeIdCounter}`;
+  const { script, bindings, strippedImports, error } = chunkDHLWNT53_js.compileSFC(code, scopeId);
+  if (error) {
+    return {
+      name: "\u8FD0\u884C\u65F6\u9884\u68C0\u67E5",
+      passed: false,
+      status: "failed",
+      errors: [error]
+    };
+  }
+  const sensitivity = detectEnvironmentSensitivity(code, strippedImports);
+  try {
+    const funcBody = `
+            "use strict";
+            ${script}
+            return { ${bindings.join(", ")} };
+        `;
+    const keys = Object.keys(MOCK_VUE_CONTEXT);
+    const values = Object.values(MOCK_VUE_CONTEXT);
+    const runner = new Function(...keys, funcBody);
+    const result = runner(...values);
+    const missingBindings = bindings.filter((binding) => !(binding in result));
+    if (missingBindings.length > 0) {
+      return {
+        name: "\u8FD0\u884C\u65F6\u9884\u68C0\u67E5",
+        passed: false,
+        status: "failed",
+        errors: missingBindings.map((b) => `\u53D8\u91CF ${b} \u672A\u6B63\u786E\u5BFC\u51FA`),
+        warnings: sensitivity.warnings.length > 0 ? sensitivity.warnings : void 0
+      };
+    }
+    return {
+      name: "\u8FD0\u884C\u65F6\u9884\u68C0\u67E5",
+      passed: true,
+      status: sensitivity.status,
+      errors: [],
+      warnings: sensitivity.warnings.length > 0 ? sensitivity.warnings : void 0
+    };
+  } catch (e) {
+    const errorMessage = e.message || String(e);
+    const errorLocation = e.stack?.split("\n")[1]?.trim() || "";
+    if (sensitivity.status === "runtime_skipped") {
+      return {
+        name: "\u8FD0\u884C\u65F6\u9884\u68C0\u67E5",
+        passed: true,
+        status: "runtime_skipped",
+        errors: [],
+        warnings: [
+          ...sensitivity.warnings,
+          `\u8FD0\u884C\u65F6\u6267\u884C\u5DF2\u8DF3\u8FC7\u4E25\u683C\u5224\u5B9A: ${errorMessage}`
+        ]
+      };
+    }
+    if (sensitivity.status === "env_dependent" && isEnvironmentRelatedRuntimeError(errorMessage)) {
+      return {
+        name: "\u8FD0\u884C\u65F6\u9884\u68C0\u67E5",
+        passed: true,
+        status: "env_dependent",
+        errors: [],
+        warnings: [
+          ...sensitivity.warnings,
+          `\u8FD0\u884C\u65F6\u6267\u884C\u53D7\u5BBF\u4E3B\u73AF\u5883\u5F71\u54CD: ${errorMessage}`
+        ]
+      };
+    }
+    return {
+      name: "\u8FD0\u884C\u65F6\u9884\u68C0\u67E5",
+      passed: false,
+      status: "failed",
+      errors: [
+        `JavaScript \u6267\u884C\u9519\u8BEF: ${errorMessage}`,
+        ...errorLocation ? [`\u4F4D\u7F6E: ${errorLocation}`] : []
+      ],
+      warnings: sensitivity.warnings.length > 0 ? sensitivity.warnings : void 0
+    };
+  }
+}
+
+exports.validateRuntimePrecheck = validateRuntimePrecheck;

package/dist/{chunk-SZYVGYKK.js → chunk-XPHDD6XR.js}

@@ -32269,7 +32269,14 @@ var ComponentRegistry = class {
         newComponents.set(resolvedData.name, resolvedData);
         if (resolvedData.subComponents) {
           for (const sub of resolvedData.subComponents) {
-            newComponents.set(sub.name, sub);
+            newComponents.set(sub.name, {
+              id: sub.name,
+              name: sub.name,
+              props: sub.props || [],
+              events: sub.events || [],
+              slots: sub.slots || [],
+              methods: sub.methods || []
+            });
           }
         }
       }
@@ -33085,23 +33092,7 @@ function checkNestingRules(tagName, metadata, ancestors, violations) {
     });
   }
 }
-function checkComponentSpecificRules(tagName, node, violations) {
-  if (tagName === "Dropdown") {
-    node.children?.forEach((child) => {
-      if (child.type === 1 && child.tag === "template") {
-        const slotProp = child.props?.find(
-          (p) => p.type === 7 && p.name === "slot" && p.arg?.content === "menu"
-        );
-        if (slotProp) {
-          violations.push({
-            rule: "DropdownMenu \u4E0D\u80FD\u653E\u5728 #menu \u63D2\u69FD\u4E2D",
-            match: "<template #menu>",
-            suggestion: "\u8BF7\u79FB\u9664 <template #menu>\uFF0C\u5C06 DropdownMenu \u76F4\u63A5\u4F5C\u4E3A Dropdown \u7684\u7B2C\u4E8C\u4E2A\u5B50\u5143\u7D20"
-          });
-        }
-      }
-    });
-  }
+function checkComponentSpecificRules(tagName, node, metadata, violations) {
   if (tagName === "Table") {
     node.props.forEach((prop) => {
       if (prop.type === 6 && (prop.name === "rowKey" || prop.name === "row-key")) {
@@ -33124,23 +33115,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;
@@ -33306,7 +33384,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);