king-design-analyzer 2.2.0 → 2.2.2

package/dist/chunk-6HOIRUQB.mjs

@@ -0,0 +1,409 @@
+import { compileSFC } from './chunk-4OTQAQ6J.mjs';
+
+// 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 } = 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
+    };
+  }
+}
+
+export { validateRuntimePrecheck };

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

@@ -1,6 +1,6 @@
-import { analyzeCodeWithAST } from './chunk-KMIDURUR.mjs';
-import { validateRuntimePrecheck } from './chunk-D2SXGGTX.mjs';
-import { compileSFC } from './chunk-BI5TIQID.mjs';
+import { analyzeCodeWithAST } from './chunk-YRGYDK2I.mjs';
+import { validateRuntimePrecheck } from './chunk-6HOIRUQB.mjs';
+import { compileSFC } from './chunk-4OTQAQ6J.mjs';
 
 // src/tools/unifiedValidator.ts
 function validateCompilation(code) {
@@ -120,6 +120,28 @@ async function validateCode(code) {
       summary: `\u274C \u8FD0\u884C\u65F6\u9519\u8BEF: ${runtimeResult.errors[0]}`
     };
   }
+  if (runtimeResult.status === "env_dependent") {
+    return {
+      passed: true,
+      layers: {
+        compilation: compilationResult,
+        ast: astResult,
+        runtime: runtimeResult
+      },
+      summary: "\u26A0\uFE0F \u8FD0\u884C\u65F6\u68C0\u67E5\u53D7\u73AF\u5883\u5F71\u54CD\uFF0C\u7ED3\u679C\u4F9D\u8D56 mock"
+    };
+  }
+  if (runtimeResult.status === "runtime_skipped") {
+    return {
+      passed: true,
+      layers: {
+        compilation: compilationResult,
+        ast: astResult,
+        runtime: runtimeResult
+      },
+      summary: "\u26A0\uFE0F \u8FD0\u884C\u65F6\u68C0\u67E5\u5DF2\u964D\u7EA7\u4E3A\u8DF3\u8FC7\u4E25\u683C\u5224\u5B9A"
+    };
+  }
   return {
     passed: true,
     layers: {
@@ -143,13 +165,14 @@ function validateCodeSync(code) {
     };
   }
   const runtimeResult = validateRuntimePrecheck(code);
+  const summary = runtimeResult.passed ? runtimeResult.status === "env_dependent" ? "\u26A0\uFE0F \u8FD0\u884C\u65F6\u68C0\u67E5\u53D7\u73AF\u5883\u5F71\u54CD" : runtimeResult.status === "runtime_skipped" ? "\u26A0\uFE0F \u8FD0\u884C\u65F6\u68C0\u67E5\u5DF2\u964D\u7EA7" : "\u2705 \u68C0\u67E5\u901A\u8FC7" : `\u274C ${runtimeResult.errors[0]}`;
   return {
     passed: runtimeResult.passed,
     layers: {
       compilation: compilationResult,
       runtime: runtimeResult
     },
-    summary: runtimeResult.passed ? "\u2705 \u68C0\u67E5\u901A\u8FC7" : `\u274C ${runtimeResult.errors[0]}`
+    summary
   };
 }
 

package/dist/{chunk-CR3GC4H3.js → chunk-DHLWNT53.js}

@@ -28,6 +28,7 @@ var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
 var ALLOWED_IMPORT_SOURCES = [
   "vue",
   "@vue/",
+  "vue-router",
   "@king-design/vue",
   "@ksyun-internal/versatile"
 ];
@@ -87,6 +88,16 @@ 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;
   }
@@ -223,7 +234,7 @@ function transformValueImports(scriptContent, whitelist, strippedImports) {
       if (reason === "relative") {
         return transformImportToBinding(importClause, `__mockModule('${source}')`);
       }
-      return "";
+      return transformImportToBinding(importClause, `__mockModule('${source}')`);
     }
   );
   nextScript = nextScript.replace(
@@ -234,7 +245,7 @@ function transformValueImports(scriptContent, whitelist, strippedImports) {
       if (reason === "relative") {
         return `__mockModule('${source}');`;
       }
-      return "";
+      return `__mockModule('${source}');`;
     }
   );
   return nextScript;

package/dist/{chunk-CJGGFVQJ.js → chunk-HARQRI4F.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkSZYVGYKK_js = require('./chunk-SZYVGYKK.js');
-var chunkEYKZY2F3_js = require('./chunk-EYKZY2F3.js');
-var chunkCR3GC4H3_js = require('./chunk-CR3GC4H3.js');
+var chunkXPHDD6XR_js = require('./chunk-XPHDD6XR.js');
+var chunkV5N65MRP_js = require('./chunk-V5N65MRP.js');
+var chunkDHLWNT53_js = require('./chunk-DHLWNT53.js');
 
 // src/tools/unifiedValidator.ts
 function validateCompilation(code) {
@@ -41,7 +41,7 @@ function validateCompilation(code) {
       errors: ["SFC \u7ED3\u6784\u9519\u8BEF: \u7F3A\u5C11 <template> \u6216 <script> \u6807\u7B7E"]
     };
   }
-  const result = chunkCR3GC4H3_js.compileSFC(code, scopeId);
+  const result = chunkDHLWNT53_js.compileSFC(code, scopeId);
   if (result.error) {
     return {
       name: "\u7F16\u8BD1\u68C0\u67E5",
@@ -64,7 +64,7 @@ function validateCompilation(code) {
 }
 async function validateAST(code) {
   try {
-    const violations = await chunkSZYVGYKK_js.analyzeCodeWithAST(code);
+    const violations = await chunkXPHDD6XR_js.analyzeCodeWithAST(code);
     if (violations.length > 0) {
       return {
         name: "AST\u89C4\u5219\u68C0\u67E5",
@@ -110,7 +110,7 @@ async function validateCode(code) {
       summary: `\u274C AST\u89C4\u5219\u8FDD\u89C4 (${astResult.errors.length}\u9879)`
     };
   }
-  const runtimeResult = chunkEYKZY2F3_js.validateRuntimePrecheck(code);
+  const runtimeResult = chunkV5N65MRP_js.validateRuntimePrecheck(code);
   if (!runtimeResult.passed) {
     return {
       passed: false,
@@ -122,6 +122,28 @@ async function validateCode(code) {
       summary: `\u274C \u8FD0\u884C\u65F6\u9519\u8BEF: ${runtimeResult.errors[0]}`
     };
   }
+  if (runtimeResult.status === "env_dependent") {
+    return {
+      passed: true,
+      layers: {
+        compilation: compilationResult,
+        ast: astResult,
+        runtime: runtimeResult
+      },
+      summary: "\u26A0\uFE0F \u8FD0\u884C\u65F6\u68C0\u67E5\u53D7\u73AF\u5883\u5F71\u54CD\uFF0C\u7ED3\u679C\u4F9D\u8D56 mock"
+    };
+  }
+  if (runtimeResult.status === "runtime_skipped") {
+    return {
+      passed: true,
+      layers: {
+        compilation: compilationResult,
+        ast: astResult,
+        runtime: runtimeResult
+      },
+      summary: "\u26A0\uFE0F \u8FD0\u884C\u65F6\u68C0\u67E5\u5DF2\u964D\u7EA7\u4E3A\u8DF3\u8FC7\u4E25\u683C\u5224\u5B9A"
+    };
+  }
   return {
     passed: true,
     layers: {
@@ -144,14 +166,15 @@ function validateCodeSync(code) {
       summary: `\u274C \u7F16\u8BD1\u5931\u8D25: ${compilationResult.errors[0]}`
     };
   }
-  const runtimeResult = chunkEYKZY2F3_js.validateRuntimePrecheck(code);
+  const runtimeResult = chunkV5N65MRP_js.validateRuntimePrecheck(code);
+  const summary = runtimeResult.passed ? runtimeResult.status === "env_dependent" ? "\u26A0\uFE0F \u8FD0\u884C\u65F6\u68C0\u67E5\u53D7\u73AF\u5883\u5F71\u54CD" : runtimeResult.status === "runtime_skipped" ? "\u26A0\uFE0F \u8FD0\u884C\u65F6\u68C0\u67E5\u5DF2\u964D\u7EA7" : "\u2705 \u68C0\u67E5\u901A\u8FC7" : `\u274C ${runtimeResult.errors[0]}`;
   return {
     passed: runtimeResult.passed,
     layers: {
       compilation: compilationResult,
       runtime: runtimeResult
     },
-    summary: runtimeResult.passed ? "\u2705 \u68C0\u67E5\u901A\u8FC7" : `\u274C ${runtimeResult.errors[0]}`
+    summary
   };
 }
 

package/dist/{chunk-TA3SV4SP.js → chunk-JJ6AB4ZH.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkCR3GC4H3_js = require('./chunk-CR3GC4H3.js');
+var chunkDHLWNT53_js = require('./chunk-DHLWNT53.js');
 
 // src/static/index.ts
 var scopeIdCounter = 0;
@@ -44,7 +44,7 @@ function validateCompilation(code) {
       errors: ["SFC \u7ED3\u6784\u9519\u8BEF: \u7F3A\u5C11 <template> \u6216 <script> \u6807\u7B7E"]
     };
   }
-  const result = chunkCR3GC4H3_js.compileSFC(code, scopeId);
+  const result = chunkDHLWNT53_js.compileSFC(code, scopeId);
   if (result.error) {
     return {
       name: "\u7F16\u8BD1\u68C0\u67E5",

package/dist/{chunk-3LYQ5XFM.mjs → chunk-NZL6T22V.mjs}

@@ -1,4 +1,4 @@
-import { compileSFC } from './chunk-BI5TIQID.mjs';
+import { compileSFC } from './chunk-4OTQAQ6J.mjs';
 
 // src/static/index.ts
 var scopeIdCounter = 0;