king-design-analyzer 2.1.7 → 2.2.0

package/dist/chunk-QC6VTSA3.mjs

@@ -0,0 +1,117 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createRequire } from 'module';
+
+// 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 createRequire(path.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.resolve(path.dirname(packageEntry), "..");
+  } catch {
+    return null;
+  }
+}
+function resolvePackageResourceDir(resourceDirName, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const packageRoot = resolvePackageRoot(options);
+  const candidates = [
+    packageRoot ? path.join(packageRoot, resourceDirName) : null,
+    path.join(cwd, resourceDirName)
+  ].filter((candidate) => Boolean(candidate));
+  return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[0];
+}
+
+export { normalizeMetadataName, resolveMetadataInheritance, resolvePackageResourceDir, resolvePackageRoot };