king-design-analyzer 2.1.9 → 2.2.1

package/dist/ast/index.d.mts

@@ -1,3 +1,5 @@
+import { C as ComponentInheritance } from '../resolve-BsLBxlBi.mjs';
+
 interface RuleViolation {
     rule: string;
     match: string;
@@ -23,9 +25,35 @@ interface ComponentProp {
 }
 interface ComponentEvent {
     name: string;
+    description?: string;
+    vueEventName?: string;
+    params?: {
+        name: string;
+        type: string;
+        description?: string;
+        optional?: boolean;
+        default?: string;
+    }[];
+    payload?: {
+        name: string;
+        type: string;
+        description?: string;
+        optional?: boolean;
+        default?: 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 MistakeEntry {
     id: string;
@@ -34,22 +62,57 @@ interface MistakeEntry {
     correctCode: string;
     explanation: string;
 }
+interface ComponentSubComponent {
+    name: string;
+    description?: string;
+    props?: ComponentProp[];
+    events?: ComponentEvent[];
+    slots?: ComponentSlot[];
+    methods?: {
+        name: string;
+        description?: string;
+        params?: {
+            name: string;
+            type: string;
+            description?: string;
+            optional?: boolean;
+            default?: string;
+        }[];
+        returnType?: string;
+    }[];
+}
 interface ComponentMetadata {
+    id?: string;
     name: string;
     props: ComponentProp[];
     events: ComponentEvent[];
     slots: ComponentSlot[];
-    subComponents?: ComponentMetadata[];
+    methods?: {
+        name: string;
+        description?: string;
+        params?: {
+            name: string;
+            type: string;
+            description?: string;
+            optional?: boolean;
+            default?: string;
+        }[];
+        returnType?: string;
+    }[];
+    subComponents?: ComponentSubComponent[];
     commonMistakes?: MistakeEntry[];
     importStatement?: string;
     requiredParent?: string;
+    inherits?: ComponentInheritance[];
 }
 declare class ComponentRegistry {
     private components;
     private loaded;
     private watcher;
     private metadataPath;
-    load(): Promise<void>;
+    load(options?: {
+        watch?: boolean;
+    }): Promise<void>;
     /**
      * 重新加载所有组件元数据
      */

package/dist/ast/index.d.ts

@@ -1,3 +1,5 @@
+import { C as ComponentInheritance } from '../resolve-BsLBxlBi.js';
+
 interface RuleViolation {
     rule: string;
     match: string;
@@ -23,9 +25,35 @@ interface ComponentProp {
 }
 interface ComponentEvent {
     name: string;
+    description?: string;
+    vueEventName?: string;
+    params?: {
+        name: string;
+        type: string;
+        description?: string;
+        optional?: boolean;
+        default?: string;
+    }[];
+    payload?: {
+        name: string;
+        type: string;
+        description?: string;
+        optional?: boolean;
+        default?: 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 MistakeEntry {
     id: string;
@@ -34,22 +62,57 @@ interface MistakeEntry {
     correctCode: string;
     explanation: string;
 }
+interface ComponentSubComponent {
+    name: string;
+    description?: string;
+    props?: ComponentProp[];
+    events?: ComponentEvent[];
+    slots?: ComponentSlot[];
+    methods?: {
+        name: string;
+        description?: string;
+        params?: {
+            name: string;
+            type: string;
+            description?: string;
+            optional?: boolean;
+            default?: string;
+        }[];
+        returnType?: string;
+    }[];
+}
 interface ComponentMetadata {
+    id?: string;
     name: string;
     props: ComponentProp[];
     events: ComponentEvent[];
     slots: ComponentSlot[];
-    subComponents?: ComponentMetadata[];
+    methods?: {
+        name: string;
+        description?: string;
+        params?: {
+            name: string;
+            type: string;
+            description?: string;
+            optional?: boolean;
+            default?: string;
+        }[];
+        returnType?: string;
+    }[];
+    subComponents?: ComponentSubComponent[];
     commonMistakes?: MistakeEntry[];
     importStatement?: string;
     requiredParent?: string;
+    inherits?: ComponentInheritance[];
 }
 declare class ComponentRegistry {
     private components;
     private loaded;
     private watcher;
     private metadataPath;
-    load(): Promise<void>;
+    load(options?: {
+        watch?: boolean;
+    }): Promise<void>;
     /**
      * 重新加载所有组件元数据
      */

package/dist/ast/index.js

@@ -1,16 +1,17 @@
 'use strict';
 
 require('../chunk-YTEYDSDW.js');
-var chunk2W6OCG2S_js = require('../chunk-2W6OCG2S.js');
+var chunkJNRGUR3O_js = require('../chunk-JNRGUR3O.js');
+require('../chunk-KF5YBEM5.js');
 require('../chunk-JSBRDJBE.js');
 
 
 
 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; }
 });

package/dist/ast/index.mjs

@@ -1,3 +1,4 @@
 import '../chunk-5H7N2A5X.mjs';
-export { analyzeCodeWithAST, componentRegistry } from '../chunk-H2ET6MMM.mjs';
+export { analyzeCodeWithAST, componentRegistry } from '../chunk-IPJJMPOO.mjs';
+import '../chunk-QC6VTSA3.mjs';
 import '../chunk-UJCSKKID.mjs';

package/dist/chunk-4OTQAQ6J.mjs

@@ -0,0 +1,341 @@
+import { parse } from '@vue/compiler-sfc';
+import { transform } from 'sucrase';
+import * as ts from 'typescript';
+
+// 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 = 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.isIdentifier(name)) {
+        bindings.add(name.text);
+        return;
+      }
+      if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+        name.elements.forEach((element) => {
+          if (ts.isBindingElement(element)) {
+            extractNames2(element.name);
+          }
+        });
+      }
+    }, visit2 = function(node) {
+      if (ts.isVariableStatement(node)) {
+        node.declarationList.declarations.forEach((decl) => extractNames2(decl.name));
+      } else if (ts.isFunctionDeclaration(node) && node.name) {
+        bindings.add(node.name.text);
+      } else if (ts.isClassDeclaration(node) && node.name) {
+        bindings.add(node.name.text);
+      }
+    };
+    var extractNames = extractNames2, visit = visit2;
+    const sourceFile = ts.createSourceFile(
+      "temp.ts",
+      scriptContent,
+      ts.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 = 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)
+    };
+  }
+}
+
+export { compileSFC, scopeStyles };

package/dist/{chunk-F26GUCGG.js → chunk-4WXOYU2N.js}

@@ -1,15 +1,15 @@
 'use strict';
 
-var chunk2W6OCG2S_js = require('./chunk-2W6OCG2S.js');
-var chunkD3Y6FGWA_js = require('./chunk-D3Y6FGWA.js');
-var chunkHPAUCD5I_js = require('./chunk-HPAUCD5I.js');
+var chunkJNRGUR3O_js = require('./chunk-JNRGUR3O.js');
+var chunkV5N65MRP_js = require('./chunk-V5N65MRP.js');
+var chunkDHLWNT53_js = require('./chunk-DHLWNT53.js');
 
 // src/tools/unifiedValidator.ts
 function validateCompilation(code) {
   const scopeId = `validate-${Date.now()}`;
   const scriptOpenCount = (code.match(/<script[\s\S]*?>/g) || []).length;
   const scriptCloseCount = (code.match(/<\/script>/g) || []).length;
-  const templateOpenCount = (code.match(/<template>/g) || []).length;
+  const templateOpenCount = (code.match(/<template[^>]*>/g) || []).length;
   const templateCloseCount = (code.match(/<\/template>/g) || []).length;
   if (scriptCloseCount > 0 && scriptOpenCount === 0) {
     return {
@@ -41,7 +41,7 @@ function validateCompilation(code) {
       errors: ["SFC \u7ED3\u6784\u9519\u8BEF: \u7F3A\u5C11 <template> \u6216 <script> \u6807\u7B7E"]
     };
   }
-  const result = chunkHPAUCD5I_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 chunk2W6OCG2S_js.analyzeCodeWithAST(code);
+    const violations = await chunkJNRGUR3O_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 = chunkD3Y6FGWA_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 = chunkD3Y6FGWA_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
   };
 }