king-design-analyzer 2.1.9 → 2.2.1

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 };