king-design-analyzer 2.1.9 → 2.2.1

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/full/index.d.mts

@@ -2,6 +2,8 @@ interface ValidationLayer {
     name: string;
     passed: boolean;
     errors: string[];
+    warnings?: string[];
+    status?: 'passed' | 'failed' | 'env_dependent' | 'runtime_skipped';
 }
 interface UnifiedValidationResult {
     passed: boolean;

package/dist/full/index.d.ts

@@ -2,6 +2,8 @@ interface ValidationLayer {
     name: string;
     passed: boolean;
     errors: string[];
+    warnings?: string[];
+    status?: 'passed' | 'failed' | 'env_dependent' | 'runtime_skipped';
 }
 interface UnifiedValidationResult {
     passed: boolean;

package/dist/full/index.js

@@ -1,18 +1,19 @@
 'use strict';
 
-var chunkF26GUCGG_js = require('../chunk-F26GUCGG.js');
-require('../chunk-2W6OCG2S.js');
-require('../chunk-D3Y6FGWA.js');
-require('../chunk-HPAUCD5I.js');
+var chunk4WXOYU2N_js = require('../chunk-4WXOYU2N.js');
+require('../chunk-JNRGUR3O.js');
+require('../chunk-V5N65MRP.js');
+require('../chunk-DHLWNT53.js');
+require('../chunk-KF5YBEM5.js');
 require('../chunk-JSBRDJBE.js');
 
 
 
 Object.defineProperty(exports, "validateCode", {
   enumerable: true,
-  get: function () { return chunkF26GUCGG_js.validateCode; }
+  get: function () { return chunk4WXOYU2N_js.validateCode; }
 });
 Object.defineProperty(exports, "validateCodeSync", {
   enumerable: true,
-  get: function () { return chunkF26GUCGG_js.validateCodeSync; }
+  get: function () { return chunk4WXOYU2N_js.validateCodeSync; }
 });

package/dist/full/index.mjs

@@ -1,5 +1,6 @@
-export { validateCode, validateCodeSync } from '../chunk-OJOHB64C.mjs';
-import '../chunk-H2ET6MMM.mjs';
-import '../chunk-NZ6TLWMD.mjs';
-import '../chunk-L4DS3EXI.mjs';
+export { validateCode, validateCodeSync } from '../chunk-LRTDTFFQ.mjs';
+import '../chunk-IPJJMPOO.mjs';
+import '../chunk-6HOIRUQB.mjs';
+import '../chunk-4OTQAQ6J.mjs';
+import '../chunk-QC6VTSA3.mjs';
 import '../chunk-UJCSKKID.mjs';

package/dist/index.d.mts

@@ -3,3 +3,4 @@ export { ComponentEvent, ComponentMetadata, ComponentProp, ComponentSlot, Mistak
 export { ValidationLayer as RuntimeValidationLayer, validateRuntimePrecheck } from './runtime/index.mjs';
 export { UnifiedValidationResult, ValidationLayer, validateCode, validateCodeSync } from './full/index.mjs';
 export { C as CompilationResult, c as compileSFC, s as scopeStyles } from './sfcCompiler-Co_Km3LU.mjs';
+import './resolve-BsLBxlBi.mjs';

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export { ComponentEvent, ComponentMetadata, ComponentProp, ComponentSlot, Mistak
 export { ValidationLayer as RuntimeValidationLayer, validateRuntimePrecheck } from './runtime/index.js';
 export { UnifiedValidationResult, ValidationLayer, validateCode, validateCodeSync } from './full/index.js';
 export { C as CompilationResult, c as compileSFC, s as scopeStyles } from './sfcCompiler-Co_Km3LU.js';
+import './resolve-BsLBxlBi.js';

package/dist/index.js

@@ -1,44 +1,45 @@
 'use strict';
 
-var chunkWYSRJVX4_js = require('./chunk-WYSRJVX4.js');
+var chunkJJ6AB4ZH_js = require('./chunk-JJ6AB4ZH.js');
 require('./chunk-YTEYDSDW.js');
-var chunkF26GUCGG_js = require('./chunk-F26GUCGG.js');
-var chunk2W6OCG2S_js = require('./chunk-2W6OCG2S.js');
-var chunkD3Y6FGWA_js = require('./chunk-D3Y6FGWA.js');
-var chunkHPAUCD5I_js = require('./chunk-HPAUCD5I.js');
+var chunk4WXOYU2N_js = require('./chunk-4WXOYU2N.js');
+var chunkJNRGUR3O_js = require('./chunk-JNRGUR3O.js');
+var chunkV5N65MRP_js = require('./chunk-V5N65MRP.js');
+var chunkDHLWNT53_js = require('./chunk-DHLWNT53.js');
+require('./chunk-KF5YBEM5.js');
 require('./chunk-JSBRDJBE.js');
 
 
 
 Object.defineProperty(exports, "validateCompilation", {
   enumerable: true,
-  get: function () { return chunkWYSRJVX4_js.validateCompilation; }
+  get: function () { return chunkJJ6AB4ZH_js.validateCompilation; }
 });
 Object.defineProperty(exports, "validateCode", {
   enumerable: true,
-  get: function () { return chunkF26GUCGG_js.validateCode; }
+  get: function () { return chunk4WXOYU2N_js.validateCode; }
 });
 Object.defineProperty(exports, "validateCodeSync", {
   enumerable: true,
-  get: function () { return chunkF26GUCGG_js.validateCodeSync; }
+  get: function () { return chunk4WXOYU2N_js.validateCodeSync; }
 });
 Object.defineProperty(exports, "analyzeCodeWithAST", {
   enumerable: true,
-  get: function () { return chunk2W6OCG2S_js.analyzeCodeWithAST; }
+  get: function () { return chunkJNRGUR3O_js.analyzeCodeWithAST; }
 });
 Object.defineProperty(exports, "componentRegistry", {
   enumerable: true,
-  get: function () { return chunk2W6OCG2S_js.componentRegistry; }
+  get: function () { return chunkJNRGUR3O_js.componentRegistry; }
 });
 Object.defineProperty(exports, "validateRuntimePrecheck", {
   enumerable: true,
-  get: function () { return chunkD3Y6FGWA_js.validateRuntimePrecheck; }
+  get: function () { return chunkV5N65MRP_js.validateRuntimePrecheck; }
 });
 Object.defineProperty(exports, "compileSFC", {
   enumerable: true,
-  get: function () { return chunkHPAUCD5I_js.compileSFC; }
+  get: function () { return chunkDHLWNT53_js.compileSFC; }
 });
 Object.defineProperty(exports, "scopeStyles", {
   enumerable: true,
-  get: function () { return chunkHPAUCD5I_js.scopeStyles; }
+  get: function () { return chunkDHLWNT53_js.scopeStyles; }
 });

package/dist/index.mjs

@@ -1,7 +1,8 @@
-export { validateCompilation } from './chunk-DSWKLUIX.mjs';
+export { validateCompilation } from './chunk-NZL6T22V.mjs';
 import './chunk-5H7N2A5X.mjs';
-export { validateCode, validateCodeSync } from './chunk-OJOHB64C.mjs';
-export { analyzeCodeWithAST, componentRegistry } from './chunk-H2ET6MMM.mjs';
-export { validateRuntimePrecheck } from './chunk-NZ6TLWMD.mjs';
-export { compileSFC, scopeStyles } from './chunk-L4DS3EXI.mjs';
+export { validateCode, validateCodeSync } from './chunk-LRTDTFFQ.mjs';
+export { analyzeCodeWithAST, componentRegistry } from './chunk-IPJJMPOO.mjs';
+export { validateRuntimePrecheck } from './chunk-6HOIRUQB.mjs';
+export { compileSFC, scopeStyles } from './chunk-4OTQAQ6J.mjs';
+import './chunk-QC6VTSA3.mjs';
 import './chunk-UJCSKKID.mjs';

package/dist/metadata/index.d.mts

@@ -1,7 +1,10 @@
+import { C as ComponentInheritance } from '../resolve-BsLBxlBi.mjs';
+
 /**
  * Components 元数据模块入口
  * 提供对 components 目录中 JSON 元数据的访问
  */
+
 /**
  * 组件元数据类型定义
  */
@@ -15,11 +18,13 @@ interface ComponentProp {
     required?: boolean;
     default?: string;
     usageExample?: string;
+    tags?: string[];
 }
 interface ComponentEvent {
     name: string;
     vueEventName?: string;
     description: string;
+    params?: ComponentActionParam[];
     payload?: {
         name: string;
         type: string;
@@ -27,11 +32,40 @@ interface ComponentEvent {
     }[];
     usageExample?: string;
 }
+interface ComponentActionParam {
+    name: string;
+    type: string;
+    description: string;
+    optional?: boolean;
+    default?: string;
+}
+interface ComponentMethod {
+    name: string;
+    description: string;
+    params?: ComponentActionParam[];
+    returnType?: string;
+    usageExample?: string;
+}
 interface ComponentSlot {
     name: string;
     description: string;
     vueTemplate?: string;
     usageExample?: string;
+    bindingType?: 'array' | 'object' | 'single' | 'none';
+    slotProps?: {
+        name: string;
+        type?: string;
+        description?: string;
+        destructuringExample?: string;
+    }[];
+}
+interface ComponentSubComponent {
+    name: string;
+    description: string;
+    props?: ComponentProp[];
+    events?: ComponentEvent[];
+    slots?: ComponentSlot[];
+    methods?: ComponentMethod[];
 }
 interface ComponentMetadata {
     id: string;
@@ -43,13 +77,14 @@ interface ComponentMetadata {
     props: ComponentProp[];
     events: ComponentEvent[];
     slots: ComponentSlot[];
-    methods?: any[];
+    methods?: ComponentMethod[];
     examples?: any[];
-    subComponents?: any[];
+    subComponents?: ComponentSubComponent[];
     commonMistakes?: any[];
     searchKeywords?: string[];
     useCases?: string[];
     relatedComponents?: string[];
+    inherits?: ComponentInheritance[];
 }
 /**
  * 获取所有可用的组件名称列表
@@ -74,4 +109,4 @@ declare function getComponentsDir(): string;
  */
 declare function getComponentPath(componentName: string): string;
 
-export { type ComponentEvent, type ComponentMetadata, type ComponentProp, type ComponentSlot, getAllComponentsMetadata, getComponentMetadata, getComponentPath, getComponentsDir, getComponentsList };
+export { type ComponentActionParam, type ComponentEvent, type ComponentMetadata, type ComponentMethod, type ComponentProp, type ComponentSlot, type ComponentSubComponent, getAllComponentsMetadata, getComponentMetadata, getComponentPath, getComponentsDir, getComponentsList };