king-design-analyzer 2.1.9 → 2.2.0

package/dist/chunk-CR3GC4H3.js

@@ -0,0 +1,353 @@
+'use strict';
+
+var compilerSfc = require('@vue/compiler-sfc');
+var sucrase = require('sucrase');
+var ts = require('typescript');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+
+// src/tools/sfcCompiler.ts
+var ALLOWED_IMPORT_SOURCES = [
+  "vue",
+  "@vue/",
+  "@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 === "@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 "";
+    }
+  );
+  nextScript = nextScript.replace(
+    /import\s+['"]([^'"]+)['"];?/g,
+    (_match, source) => {
+      const reason = classifyImportSource(source, whitelist);
+      strippedImports.push({ source, reason });
+      if (reason === "relative") {
+        return `__mockModule('${source}');`;
+      }
+      return "";
+    }
+  );
+  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 = sucrase.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__namespace.isIdentifier(name)) {
+        bindings.add(name.text);
+        return;
+      }
+      if (ts__namespace.isObjectBindingPattern(name) || ts__namespace.isArrayBindingPattern(name)) {
+        name.elements.forEach((element) => {
+          if (ts__namespace.isBindingElement(element)) {
+            extractNames2(element.name);
+          }
+        });
+      }
+    }, visit2 = function(node) {
+      if (ts__namespace.isVariableStatement(node)) {
+        node.declarationList.declarations.forEach((decl) => extractNames2(decl.name));
+      } else if (ts__namespace.isFunctionDeclaration(node) && node.name) {
+        bindings.add(node.name.text);
+      } else if (ts__namespace.isClassDeclaration(node) && node.name) {
+        bindings.add(node.name.text);
+      }
+    };
+    var extractNames = extractNames2, visit = visit2;
+    const sourceFile = ts__namespace.createSourceFile(
+      "temp.ts",
+      scriptContent,
+      ts__namespace.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 = compilerSfc.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)
+    };
+  }
+}
+
+exports.compileSFC = compileSFC;
+exports.scopeStyles = scopeStyles;

package/dist/{chunk-NZ6TLWMD.mjs → chunk-D2SXGGTX.mjs}

@@ -1,7 +1,32 @@
-import { compileSFC } from './chunk-L4DS3EXI.mjs';
+import { compileSFC } from './chunk-BI5TIQID.mjs';
 
 // src/runtime/index.ts
 var scopeIdCounter = 0;
+function createMockProxy(path) {
+  return new Proxy(() => {
+  }, {
+    get: (_target, prop) => {
+      if (prop === Symbol.toPrimitive) return () => 0;
+      if (prop === "then") return void 0;
+      return createMockProxy();
+    },
+    apply: () => createMockProxy()
+  });
+}
+function createWhitelistedModule(source, context) {
+  if (source === "vue" || source.startsWith("@vue/")) {
+    return context;
+  }
+  return new Proxy({}, {
+    get: (_target, prop) => {
+      if (prop === "default") return createMockProxy();
+      if (typeof prop === "string" && prop in context) {
+        return context[prop];
+      }
+      return createMockProxy();
+    }
+  });
+}
 var MOCK_VUE_CONTEXT = {
   // Reactivity
   ref: (v) => ({ value: v }),
@@ -84,22 +109,8 @@ var MOCK_VUE_CONTEXT = {
   // =========================================================================
   // Module Mocking
   // =========================================================================
-  __mockModule: (modulePath) => {
-    const createMockProxy = (path) => {
-      return new Proxy(() => {
-      }, {
-        get: (target, prop) => {
-          if (prop === Symbol.toPrimitive) return () => 0;
-          if (prop === "then") return void 0;
-          return createMockProxy();
-        },
-        apply: (target, thisArg, args) => {
-          return createMockProxy();
-        }
-      });
-    };
-    return createMockProxy();
-  }
+  __mockModule: (modulePath) => createMockProxy(),
+  __getWhitelistedModule: (source) => createWhitelistedModule(source, MOCK_VUE_CONTEXT)
 };
 function validateRuntimePrecheck(code) {
   const scopeId = `runtime-${Date.now()}-${++scopeIdCounter}`;

package/dist/{chunk-D3Y6FGWA.js → chunk-EYKZY2F3.js}

@@ -1,9 +1,34 @@
 'use strict';
 
-var chunkHPAUCD5I_js = require('./chunk-HPAUCD5I.js');
+var chunkCR3GC4H3_js = require('./chunk-CR3GC4H3.js');
 
 // src/runtime/index.ts
 var scopeIdCounter = 0;
+function createMockProxy(path) {
+  return new Proxy(() => {
+  }, {
+    get: (_target, prop) => {
+      if (prop === Symbol.toPrimitive) return () => 0;
+      if (prop === "then") return void 0;
+      return createMockProxy();
+    },
+    apply: () => createMockProxy()
+  });
+}
+function createWhitelistedModule(source, context) {
+  if (source === "vue" || source.startsWith("@vue/")) {
+    return context;
+  }
+  return new Proxy({}, {
+    get: (_target, prop) => {
+      if (prop === "default") return createMockProxy();
+      if (typeof prop === "string" && prop in context) {
+        return context[prop];
+      }
+      return createMockProxy();
+    }
+  });
+}
 var MOCK_VUE_CONTEXT = {
   // Reactivity
   ref: (v) => ({ value: v }),
@@ -86,26 +111,12 @@ var MOCK_VUE_CONTEXT = {
   // =========================================================================
   // Module Mocking
   // =========================================================================
-  __mockModule: (modulePath) => {
-    const createMockProxy = (path) => {
-      return new Proxy(() => {
-      }, {
-        get: (target, prop) => {
-          if (prop === Symbol.toPrimitive) return () => 0;
-          if (prop === "then") return void 0;
-          return createMockProxy();
-        },
-        apply: (target, thisArg, args) => {
-          return createMockProxy();
-        }
-      });
-    };
-    return createMockProxy();
-  }
+  __mockModule: (modulePath) => createMockProxy(),
+  __getWhitelistedModule: (source) => createWhitelistedModule(source, MOCK_VUE_CONTEXT)
 };
 function validateRuntimePrecheck(code) {
   const scopeId = `runtime-${Date.now()}-${++scopeIdCounter}`;
-  const { script, bindings, strippedImports, error } = chunkHPAUCD5I_js.compileSFC(code, scopeId);
+  const { script, bindings, strippedImports, error } = chunkCR3GC4H3_js.compileSFC(code, scopeId);
   if (error) {
     return {
       name: "\u8FD0\u884C\u65F6\u9884\u68C0\u67E5",

package/dist/chunk-KF5YBEM5.js

@@ -0,0 +1,143 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var module$1 = require('module');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/metadata/resolve.ts
+function normalizeMetadataName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function findMetadata(lookup, componentName) {
+  if (lookup[componentName]) return lookup[componentName];
+  const normalized = normalizeMetadataName(componentName);
+  return Object.values(lookup).find(
+    (item) => normalizeMetadataName(item.name) === normalized || normalizeMetadataName(item.id || "") === normalized
+  );
+}
+function mergeNamedItems(inheritedItems = [], localItems = [], sourceName, excludeNames, annotateTags = false) {
+  const merged = /* @__PURE__ */ new Map();
+  const excluded = new Set(excludeNames.map(normalizeMetadataName));
+  for (const item of inheritedItems) {
+    if (!item?.name || excluded.has(normalizeMetadataName(item.name))) continue;
+    const nextItem = annotateTags ? {
+      ...item,
+      tags: [.../* @__PURE__ */ new Set([...item.tags || [], `inherited:${sourceName}`])]
+    } : { ...item };
+    merged.set(normalizeMetadataName(item.name), nextItem);
+  }
+  for (const item of localItems) {
+    if (!item?.name) continue;
+    merged.set(normalizeMetadataName(item.name), item);
+  }
+  return Array.from(merged.values());
+}
+function resolveMetadataInheritance(metadata, lookup, visited = /* @__PURE__ */ new Set()) {
+  const visitKey = normalizeMetadataName(metadata.name || metadata.id || "");
+  if (!visitKey || visited.has(visitKey)) {
+    return metadata;
+  }
+  const nextVisited = new Set(visited);
+  nextVisited.add(visitKey);
+  let resolvedProps = [...metadata.props || []];
+  let resolvedEvents = [...metadata.events || []];
+  let resolvedSlots = [...metadata.slots || []];
+  let resolvedMethods = [...metadata.methods || []];
+  for (const inheritance of metadata.inherits || []) {
+    const parent = findMetadata(lookup, inheritance.component);
+    if (!parent) continue;
+    const resolvedParent = resolveMetadataInheritance(parent, lookup, nextVisited);
+    const include = inheritance.include || ["props", "events", "slots", "methods"];
+    const exclude = inheritance.exclude || [];
+    if (include.includes("props")) {
+      resolvedProps = mergeNamedItems(
+        resolvedParent.props || [],
+        resolvedProps,
+        resolvedParent.name,
+        exclude,
+        true
+      );
+    }
+    if (include.includes("events")) {
+      resolvedEvents = mergeNamedItems(
+        resolvedParent.events || [],
+        resolvedEvents,
+        resolvedParent.name,
+        exclude
+      );
+    }
+    if (include.includes("slots")) {
+      resolvedSlots = mergeNamedItems(
+        resolvedParent.slots || [],
+        resolvedSlots,
+        resolvedParent.name,
+        exclude
+      );
+    }
+    if (include.includes("methods")) {
+      resolvedMethods = mergeNamedItems(
+        resolvedParent.methods || [],
+        resolvedMethods,
+        resolvedParent.name,
+        exclude
+      );
+    }
+  }
+  return {
+    ...metadata,
+    props: resolvedProps,
+    events: resolvedEvents,
+    slots: resolvedSlots,
+    methods: resolvedMethods
+  };
+}
+var DEFAULT_PACKAGE_NAME = "king-design-analyzer";
+function createPackageRequire(cwd) {
+  return module$1.createRequire(path__namespace.join(cwd, "package.json"));
+}
+function resolvePackageRoot(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const packageName = options.packageName || DEFAULT_PACKAGE_NAME;
+  try {
+    const moduleRequire = createPackageRequire(cwd);
+    const packageEntry = moduleRequire.resolve(packageName);
+    return path__namespace.resolve(path__namespace.dirname(packageEntry), "..");
+  } catch {
+    return null;
+  }
+}
+function resolvePackageResourceDir(resourceDirName, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const packageRoot = resolvePackageRoot(options);
+  const candidates = [
+    packageRoot ? path__namespace.join(packageRoot, resourceDirName) : null,
+    path__namespace.join(cwd, resourceDirName)
+  ].filter((candidate) => Boolean(candidate));
+  return candidates.find((candidate) => fs__namespace.existsSync(candidate)) || candidates[0];
+}
+
+exports.normalizeMetadataName = normalizeMetadataName;
+exports.resolveMetadataInheritance = resolveMetadataInheritance;
+exports.resolvePackageResourceDir = resolvePackageResourceDir;
+exports.resolvePackageRoot = resolvePackageRoot;