@fragments-sdk/mcp 0.9.0 → 0.10.0

package/dist/{dist-BDWAHJ4K.js → dist-TTCI6TME.js}

@@ -30016,8 +30016,8 @@ var require_traverseForScope = __commonJS({
         _context._forceSetScope.call(path2);
         const visitor = exploded[node.type];
         if (visitor != null && visitor.enter) {
-          for (const visit of visitor.enter) {
-            visit.call(state, path2, state);
+          for (const visit2 of visitor.enter) {
+            visit2.call(state, path2, state);
           }
         }
         if (path2.shouldSkip) {
@@ -30040,8 +30040,8 @@ var require_traverseForScope = __commonJS({
           }
         }
         if (visitor != null && visitor.exit) {
-          for (const visit of visitor.exit) {
-            visit.call(state, path2, state);
+          for (const visit2 of visitor.exit) {
+            visit2.call(state, path2, state);
           }
         }
       }
@@ -30946,8 +30946,8 @@ var require_scope = __commonJS({
         if (path.type !== "Program") {
           const typeVisitors = scopeVisitor[path.type];
           if (typeVisitors) {
-            for (const visit of typeVisitors.enter) {
-              visit.call(state, path, state);
+            for (const visit2 of typeVisitors.enter) {
+              visit2.call(state, path, state);
             }
           }
         }
@@ -31338,7 +31338,7 @@ var require_sourcemap_codec_umd = __commonJS({
         intToChar[i] = c;
         charToInt[c] = i;
       }
-      function decodeInteger(reader, relative) {
+      function decodeInteger(reader, relative2) {
         let value = 0;
         let shift = 0;
         let integer = 0;
@@ -31353,10 +31353,10 @@ var require_sourcemap_codec_umd = __commonJS({
         if (shouldNegate) {
           value = -2147483648 | -value;
         }
-        return relative + value;
+        return relative2 + value;
       }
-      function encodeInteger(builder, num, relative) {
-        let delta = num - relative;
+      function encodeInteger(builder, num, relative2) {
+        let delta = num - relative2;
         delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
         do {
           let clamped = delta & 31;
@@ -31861,7 +31861,7 @@ var require_resolve_uri_umd = __commonJS({
         }
         url.path = path;
       }
-      function resolve4(input, base) {
+      function resolve5(input, base) {
         if (!input && !base)
           return "";
         const url = parseUrl(input);
@@ -31914,7 +31914,7 @@ var require_resolve_uri_umd = __commonJS({
             return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
         }
       }
-      return resolve4;
+      return resolve5;
     }));
   }
 });
@@ -32260,8 +32260,8 @@ var require_trace_mapping_umd = __commonJS({
           this.sources = sources;
           this.sourcesContent = sourcesContent;
           this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
-          const resolve4 = resolver(mapUrl, sourceRoot);
-          this.resolvedSources = sources.map(resolve4);
+          const resolve5 = resolver(mapUrl, sourceRoot);
+          this.resolvedSources = sources.map(resolve5);
           const { mappings } = parsed;
           if (typeof mappings === "string") {
             this._encoded = mappings;
@@ -55555,7 +55555,7 @@ var require_introspection = __commonJS({
     exports.isStatic = isStatic;
     exports.matchesPattern = matchesPattern;
     exports.referencesImport = referencesImport;
-    exports.resolve = resolve4;
+    exports.resolve = resolve5;
     exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
     var _t = require_lib4();
     var {
@@ -55813,7 +55813,7 @@ var require_introspection = __commonJS({
       nodeMap.set(target.node, result);
       return result;
     }
-    function resolve4(dangerous, resolved) {
+    function resolve5(dangerous, resolved) {
       return _resolve.call(this, dangerous, resolved) || this;
     }
     function _resolve(dangerous, resolved) {
@@ -56846,7 +56846,7 @@ var require_context2 = __commonJS({
     exports.skip = skip;
     exports.skipKey = skipKey;
     exports.stop = stop;
-    exports.visit = visit;
+    exports.visit = visit2;
     var _traverseNode = require_traverse_node();
     var _index = require_path();
     var _removal = require_removal();
@@ -56894,7 +56894,7 @@ var require_context2 = __commonJS({
         path.opts = context.opts;
       }
     }
-    function visit() {
+    function visit2() {
       var _this$opts$shouldSkip, _this$opts;
       if (!this.node) {
         return false;
@@ -57199,6 +57199,11 @@ import {
 import {
   makeTailwindTokenResolvedFact
 } from "@fragments-sdk/core";
+import { createHash } from "crypto";
+import ts4 from "typescript";
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname4, isAbsolute, relative, resolve as resolve4 } from "path";
+import ts3 from "typescript";
 var require2 = __banner_createRequire(import.meta.url);
 function createComponentExtractor(tsconfigPath) {
   let projectVersion = 0;
@@ -59032,7 +59037,7 @@ function handleAttributeValue(attr, ctx) {
 function handleExpression(expr, ctx, fallbackLocation, exprContext, origin = "attribute") {
   const acc = [];
   let emittedDynamic = false;
-  const visit = (node) => {
+  const visit2 = (node) => {
     if (t2.isStringLiteral(node)) {
       acc.push(...splitClassString(node.value));
       return;
@@ -59115,7 +59120,7 @@ function handleExpression(expr, ctx, fallbackLocation, exprContext, origin = "at
     emittedDynamic = true;
     emitOpaque(ctx, node, fallbackLocation);
   };
-  visit(expr);
+  visit2(expr);
   if (exprContext === "attribute" && acc.length > 0) {
     emitLiteral(ctx, origin, acc, locFromNode(expr, ctx.file) ?? fallbackLocation);
   }
@@ -60239,6 +60244,703 @@ function summarizeCallSites(callSites) {
 function compareCallSites(a, b) {
   return String(a.componentId).localeCompare(String(b.componentId)) || a.filePath.localeCompare(b.filePath) || a.line - b.line || a.column - b.column || a.nodePath.localeCompare(b.nodePath);
 }
+var HASH_LENGTH = 16;
+function ucfId(filePath, componentName, framework, sourceCommit) {
+  const key = `${framework}|${filePath}|${componentName}|${sourceCommit}`;
+  return createHash("sha256").update(key).digest("hex").slice(0, HASH_LENGTH);
+}
+var MAX_ROOT_BRANCHES = 4;
+var MAX_CLASSNAMES = 64;
+var REACT_HOOK_STATE = /* @__PURE__ */ new Set(["useState", "useReducer"]);
+var REACT_HOOK_EFFECT = /* @__PURE__ */ new Set(["useEffect", "useLayoutEffect", "useInsertionEffect"]);
+var WRAPPER_NAMES = /* @__PURE__ */ new Set([
+  "forwardRef",
+  "memo",
+  "observer",
+  "styled"
+]);
+function mapDefinitionKind(declaration) {
+  if (ts3.isClassDeclaration(declaration) || ts3.isClassExpression(declaration)) {
+    return { kind: "class", wrappedBy: [], inner: declaration };
+  }
+  if (ts3.isFunctionDeclaration(declaration)) {
+    return { kind: "function", wrappedBy: [], inner: declaration };
+  }
+  if (ts3.isArrowFunction(declaration) || ts3.isFunctionExpression(declaration)) {
+    return { kind: "function", wrappedBy: [], inner: declaration };
+  }
+  if (ts3.isCallExpression(declaration)) {
+    const wrappedBy = [];
+    let cursor = declaration;
+    while (ts3.isCallExpression(cursor)) {
+      const name = getCalleeName(cursor.expression);
+      if (name && WRAPPER_NAMES.has(name)) {
+        wrappedBy.push(name);
+        const first = cursor.arguments[0];
+        if (!first) break;
+        cursor = first;
+      } else {
+        break;
+      }
+    }
+    if (wrappedBy.length > 0) {
+      return { kind: "wrapper", wrappedBy, inner: cursor };
+    }
+  }
+  return { kind: "function", wrappedBy: [], inner: null };
+}
+function getCalleeName(expr) {
+  if (ts3.isIdentifier(expr)) return expr.text;
+  if (ts3.isPropertyAccessExpression(expr)) return expr.name.text;
+  return null;
+}
+function mapImports(sourceFile) {
+  const records = [];
+  for (const stmt of sourceFile.statements) {
+    if (!ts3.isImportDeclaration(stmt)) continue;
+    if (!ts3.isStringLiteral(stmt.moduleSpecifier)) continue;
+    const moduleSpecifier = stmt.moduleSpecifier.text;
+    const importedNames = [];
+    if (stmt.importClause) {
+      if (stmt.importClause.name) {
+        importedNames.push({
+          imported: "default",
+          local: stmt.importClause.name.text
+        });
+      }
+      const bindings = stmt.importClause.namedBindings;
+      if (bindings) {
+        if (ts3.isNamespaceImport(bindings)) {
+          importedNames.push({
+            imported: "*",
+            local: bindings.name.text
+          });
+        } else if (ts3.isNamedImports(bindings)) {
+          for (const element of bindings.elements) {
+            importedNames.push({
+              imported: element.propertyName?.text ?? element.name.text,
+              local: element.name.text
+            });
+          }
+        }
+      }
+    }
+    records.push({
+      moduleSpecifier,
+      resolvedPackage: resolvePackageName(moduleSpecifier),
+      importedNames
+    });
+  }
+  return records;
+}
+function resolvePackageName(spec) {
+  if (spec.startsWith(".") || spec.startsWith("/")) return void 0;
+  if (spec.startsWith("@")) {
+    const parts = spec.split("/");
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : spec;
+  }
+  return spec.split("/")[0];
+}
+function mapFileExports(sourceFile) {
+  const seen = /* @__PURE__ */ new Set();
+  const exportNames = [];
+  function add(name) {
+    if (seen.has(name)) return;
+    seen.add(name);
+    exportNames.push(name);
+  }
+  for (const stmt of sourceFile.statements) {
+    if (ts3.isVariableStatement(stmt) && hasExportModifier(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (ts3.isIdentifier(decl.name)) add(decl.name.text);
+      }
+    } else if (ts3.isFunctionDeclaration(stmt) && hasExportModifier(stmt) && stmt.name) {
+      add(stmt.name.text);
+    } else if (ts3.isClassDeclaration(stmt) && hasExportModifier(stmt) && stmt.name) {
+      add(stmt.name.text);
+    } else if (ts3.isExportAssignment(stmt)) {
+      add("default");
+    } else if (ts3.isExportDeclaration(stmt) && stmt.exportClause) {
+      if (ts3.isNamedExports(stmt.exportClause)) {
+        for (const element of stmt.exportClause.elements) {
+          add(element.name.text);
+        }
+      }
+    }
+  }
+  const baseName = sourceFile.fileName.split("/").pop() ?? "";
+  const exportedFromBarrel = /^index\.(t|j)sx?$/.test(baseName);
+  return { exportNames, exportedFromBarrel };
+}
+function hasExportModifier(node) {
+  const modifiers = ts3.canHaveModifiers(node) ? ts3.getModifiers(node) : void 0;
+  return modifiers?.some((m) => m.kind === ts3.SyntaxKind.ExportKeyword) ?? false;
+}
+function mapRootElements(inner) {
+  if (!inner) return { rootElements: [], rootElementsTruncated: false };
+  const branches = [];
+  collectReturnedJsx(inner, branches, void 0);
+  let truncated = false;
+  if (branches.length > MAX_ROOT_BRANCHES) {
+    truncated = true;
+    branches.length = MAX_ROOT_BRANCHES;
+  }
+  const rootElements = branches.map(({ jsx, guard }) => toRootElementFact(jsx, guard));
+  return { rootElements, rootElementsTruncated: truncated };
+}
+function collectReturnedJsx(node, acc, guard) {
+  if (!node) return;
+  if (ts3.isReturnStatement(node)) {
+    if (node.expression) collectFromExpression(node.expression, acc, guard);
+    return;
+  }
+  if (ts3.isArrowFunction(node) && !ts3.isBlock(node.body)) {
+    collectFromExpression(node.body, acc, guard);
+    return;
+  }
+  if (ts3.isIfStatement(node)) {
+    const thenGuard = node.expression.getText();
+    walk(node.thenStatement, acc, combineGuards(guard, thenGuard));
+    if (node.elseStatement) {
+      walk(node.elseStatement, acc, combineGuards(guard, `!(${thenGuard})`));
+    }
+    return;
+  }
+  ts3.forEachChild(node, (child) => walk(child, acc, guard));
+}
+function walk(node, acc, guard) {
+  if (acc.length >= MAX_ROOT_BRANCHES + 1) return;
+  collectReturnedJsx(node, acc, guard);
+}
+function collectFromExpression(expr, acc, guard) {
+  if (acc.length >= MAX_ROOT_BRANCHES + 1) return;
+  const stripped = stripParens(expr);
+  if (ts3.isConditionalExpression(stripped)) {
+    const condText = stripped.condition.getText();
+    collectFromExpression(stripped.whenTrue, acc, combineGuards(guard, condText));
+    collectFromExpression(stripped.whenFalse, acc, combineGuards(guard, `!(${condText})`));
+    return;
+  }
+  if (ts3.isBinaryExpression(stripped) && stripped.operatorToken.kind === ts3.SyntaxKind.AmpersandAmpersandToken) {
+    const condText = stripped.left.getText();
+    collectFromExpression(stripped.right, acc, combineGuards(guard, condText));
+    return;
+  }
+  if (ts3.isJsxElement(stripped) || ts3.isJsxSelfClosingElement(stripped)) {
+    const opening = ts3.isJsxElement(stripped) ? stripped.openingElement : stripped;
+    acc.push({ jsx: opening, guard });
+    return;
+  }
+  if (ts3.isJsxFragment(stripped)) {
+    acc.push({ jsx: stripped, guard });
+    return;
+  }
+}
+function stripParens(expr) {
+  while (ts3.isParenthesizedExpression(expr) || ts3.isAsExpression(expr)) {
+    expr = expr.expression;
+  }
+  return expr;
+}
+function combineGuards(prev, next) {
+  return prev ? `${prev} && ${next}` : next;
+}
+function toRootElementFact(jsx, guard) {
+  if (ts3.isJsxFragment(jsx)) {
+    return { tag: "Fragment", attrs: {}, conditionalGuard: guard };
+  }
+  const tagName = jsx.tagName.getText();
+  const isHtml = /^[a-z]/.test(tagName);
+  const tag = isHtml ? tagName : `Custom:${tagName}`;
+  const attrs = {};
+  let inputType;
+  for (const attr of jsx.attributes.properties) {
+    if (!ts3.isJsxAttribute(attr)) continue;
+    const name = attr.name.getText();
+    const value = readAttrValue(attr);
+    if (value !== void 0) attrs[name] = value;
+    if (name === "type" && tag === "input" && typeof value === "string") {
+      inputType = value;
+    }
+  }
+  const fact = { tag, attrs };
+  if (inputType) fact.inputType = inputType;
+  if (guard) fact.conditionalGuard = guard;
+  return fact;
+}
+function readAttrValue(attr) {
+  if (!attr.initializer) return true;
+  if (ts3.isStringLiteral(attr.initializer)) return attr.initializer.text;
+  if (ts3.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    const inner = attr.initializer.expression;
+    if (ts3.isStringLiteral(inner) || ts3.isNoSubstitutionTemplateLiteral(inner)) {
+      return inner.text;
+    }
+  }
+  return void 0;
+}
+function mapAria(rootElements) {
+  const roles = /* @__PURE__ */ new Set();
+  const attributes = {};
+  for (const root of rootElements) {
+    for (const [key, value] of Object.entries(root.attrs)) {
+      if (key === "role" && typeof value === "string") roles.add(value);
+      if (key.startsWith("aria-")) attributes[key] = value;
+    }
+  }
+  return { ariaRoles: [...roles], ariaAttributes: attributes };
+}
+function mapProps(inner, checker) {
+  if (!inner) return [];
+  const propsType = resolvePropsType(inner, checker);
+  if (!propsType) return [];
+  const defaults = collectDestructuredDefaults(inner);
+  const facts = [];
+  const ownerSourceFile = inner.getSourceFile();
+  for (const symbol of propsType.getProperties()) {
+    const decl = symbol.getDeclarations()?.[0];
+    if (decl && !isUserDeclaration(decl, ownerSourceFile)) continue;
+    const declNode = decl ?? inner;
+    const propType = checker.getTypeOfSymbolAtLocation(symbol, declNode);
+    const optional = (symbol.flags & ts3.SymbolFlags.Optional) !== 0;
+    const typeText = checker.typeToString(propType, declNode);
+    const fact = {
+      name: symbol.getName(),
+      typeText,
+      optional,
+      hasDefault: defaults.has(symbol.getName()),
+      isUnion: propType.isUnion()
+    };
+    if (fact.hasDefault) {
+      fact.defaultValueText = defaults.get(symbol.getName());
+    }
+    if (propType.isUnion()) {
+      fact.unionMembers = unionMembers(propType, declNode, checker);
+    }
+    const jsdocText = getJsDocText(symbol);
+    if (jsdocText) fact.jsdoc = jsdocText;
+    facts.push(fact);
+  }
+  return facts;
+}
+function resolvePropsType(node, checker) {
+  if (ts3.isFunctionDeclaration(node) || ts3.isArrowFunction(node) || ts3.isFunctionExpression(node)) {
+    const param = node.parameters[0];
+    if (!param) return null;
+    return checker.getTypeAtLocation(param);
+  }
+  if (ts3.isClassDeclaration(node) || ts3.isClassExpression(node)) {
+    const heritage = node.heritageClauses?.[0]?.types?.[0];
+    if (heritage?.typeArguments?.[0]) {
+      return checker.getTypeFromTypeNode(heritage.typeArguments[0]);
+    }
+  }
+  return null;
+}
+function collectDestructuredDefaults(node) {
+  const defaults = /* @__PURE__ */ new Map();
+  if (!ts3.isFunctionDeclaration(node) && !ts3.isArrowFunction(node) && !ts3.isFunctionExpression(node)) {
+    return defaults;
+  }
+  const param = node.parameters[0];
+  if (!param || !ts3.isObjectBindingPattern(param.name)) return defaults;
+  for (const element of param.name.elements) {
+    if (!ts3.isIdentifier(element.name)) continue;
+    if (!element.initializer) continue;
+    const propName = element.propertyName ? element.propertyName.getText() : element.name.text;
+    defaults.set(propName, element.initializer.getText());
+  }
+  return defaults;
+}
+function isUserDeclaration(decl, owner) {
+  const declSource = decl.getSourceFile();
+  if (declSource === owner) return true;
+  return !declSource.fileName.includes("node_modules");
+}
+function unionMembers(type, location, checker) {
+  if (!type.isUnion()) return [];
+  const members = type.types.map((t4) => checker.typeToString(t4, location));
+  return [...new Set(members)].sort();
+}
+function getJsDocText(symbol) {
+  const tags = symbol.getDocumentationComment(void 0);
+  if (!tags || tags.length === 0) return void 0;
+  return ts3.displayPartsToString(tags).trim() || void 0;
+}
+function mapBehaviorHints(inner, props) {
+  let hasInternalState = false;
+  let hasEffects = false;
+  if (inner) {
+    visit(inner, (node) => {
+      if (hasInternalState && hasEffects) return false;
+      if (ts3.isCallExpression(node)) {
+        const name = getCalleeName(node.expression);
+        if (name && REACT_HOOK_STATE.has(name)) hasInternalState = true;
+        if (name && REACT_HOOK_EFFECT.has(name)) hasEffects = true;
+      }
+      return true;
+    });
+  }
+  return { hasInternalState, hasEffects, isControlled: inferControlled(props) };
+}
+function visit(node, fn) {
+  if (fn(node) === false) return;
+  ts3.forEachChild(node, (child) => visit(child, fn));
+}
+function inferControlled(props) {
+  const names = new Set(props.map((p) => p.name));
+  const hasValue = names.has("value") || names.has("checked");
+  const hasOnChange = names.has("onChange") || names.has("onValueChange") || names.has("onCheckedChange");
+  const hasDefault = names.has("defaultValue") || names.has("defaultChecked");
+  if (hasValue && hasOnChange && hasDefault) return "mixed";
+  if (hasValue && hasOnChange) return true;
+  if (hasDefault && !hasValue) return false;
+  return "unknown";
+}
+function mapFileCompoundChildren(sourceFile) {
+  const result = /* @__PURE__ */ new Map();
+  function bucket(name) {
+    let set = result.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      result.set(name, set);
+    }
+    return set;
+  }
+  for (const stmt of sourceFile.statements) {
+    if (ts3.isExpressionStatement(stmt) && ts3.isCallExpression(stmt.expression)) {
+      const target = readObjectAssignTarget(stmt.expression);
+      if (target) collectAssignedMembers(stmt.expression, bucket(target.text));
+    }
+    if (ts3.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (ts3.isIdentifier(decl.name) && decl.initializer && ts3.isCallExpression(decl.initializer) && isObjectAssignCallee(decl.initializer.expression)) {
+          collectAssignedMembers(decl.initializer, bucket(decl.name.text));
+        }
+      }
+    }
+    if (ts3.isExpressionStatement(stmt) && ts3.isBinaryExpression(stmt.expression)) {
+      const expr = stmt.expression;
+      if (expr.operatorToken.kind === ts3.SyntaxKind.EqualsToken && ts3.isPropertyAccessExpression(expr.left) && ts3.isIdentifier(expr.left.expression)) {
+        bucket(expr.left.expression.text).add(expr.left.name.text);
+      }
+    }
+  }
+  const flattened = /* @__PURE__ */ new Map();
+  for (const [name, set] of result) flattened.set(name, [...set]);
+  return flattened;
+}
+function isObjectAssignCallee(callee) {
+  return ts3.isPropertyAccessExpression(callee) && ts3.isIdentifier(callee.expression) && callee.expression.text === "Object" && callee.name.text === "assign";
+}
+function readObjectAssignTarget(call) {
+  if (!isObjectAssignCallee(call.expression)) return null;
+  const target = call.arguments[0];
+  return target && ts3.isIdentifier(target) ? target : null;
+}
+function collectAssignedMembers(call, into) {
+  const members = call.arguments[1];
+  if (!members || !ts3.isObjectLiteralExpression(members)) return;
+  for (const prop of members.properties) {
+    if (ts3.isShorthandPropertyAssignment(prop)) {
+      into.add(prop.name.text);
+    } else if (ts3.isPropertyAssignment(prop) && ts3.isIdentifier(prop.name)) {
+      into.add(prop.name.text);
+    }
+  }
+}
+function mapStyleSystem(sourceFile, imports) {
+  const styleSystem = detectStyleSystem(imports);
+  const classNamesUsed = collectClassNames(sourceFile);
+  return { styleSystem, classNamesUsed };
+}
+function detectStyleSystem(imports) {
+  for (const record of imports) {
+    const spec = record.moduleSpecifier;
+    if (/\.module\.(s?c|sa)ss$/.test(spec)) return "cssModules";
+    if (spec === "styled-components") return "styledComponents";
+    if (spec === "@emotion/styled" || spec === "@emotion/react") return "cssInJs";
+    if (spec === "@stitches/react") return "cssInJs";
+    if (/^@?tailwind/.test(spec) || spec === "tailwindcss") return "tailwind";
+    if (/\.scss$/.test(spec) || /\.sass$/.test(spec)) return "sass";
+    if (/\.css$/.test(spec)) return "plainCss";
+  }
+  return "unknown";
+}
+function collectClassNames(sourceFile) {
+  const seen = /* @__PURE__ */ new Set();
+  visit(sourceFile, (node) => {
+    if (seen.size >= MAX_CLASSNAMES) return false;
+    if (!ts3.isJsxAttribute(node)) return true;
+    if (node.name.getText() !== "className") return true;
+    if (!node.initializer) return true;
+    if (ts3.isStringLiteral(node.initializer)) {
+      addClasses(node.initializer.text, seen);
+      return true;
+    }
+    if (ts3.isJsxExpression(node.initializer) && node.initializer.expression) {
+      const expr = node.initializer.expression;
+      if (ts3.isStringLiteral(expr) || ts3.isNoSubstitutionTemplateLiteral(expr)) {
+        addClasses(expr.text, seen);
+      }
+    }
+    return true;
+  });
+  return [...seen];
+}
+function addClasses(raw, seen) {
+  for (const cls of raw.split(/\s+/)) {
+    if (!cls) continue;
+    if (seen.size >= MAX_CLASSNAMES) return;
+    seen.add(cls);
+  }
+}
+function mapJsdoc(declaration, sourceFile) {
+  const result = {};
+  if (declaration) {
+    const jsDocs = ts3.getJSDocCommentsAndTags(declaration);
+    for (const doc of jsDocs) {
+      if (ts3.isJSDoc(doc) && doc.comment) {
+        const text2 = jsdocCommentToString(doc.comment);
+        const firstSentence = text2.split(/(?<=\.)\s/)[0]?.trim();
+        if (firstSentence) {
+          result.jsdocDescription = firstSentence;
+          break;
+        }
+      }
+    }
+  }
+  const text = sourceFile.getFullText();
+  const headerMatch = text.match(/^\s*\/\*\*[\s\S]*?\*\//);
+  if (headerMatch) {
+    result.fileHeaderComment = headerMatch[0].replace(/^\s*\/\*\*/, "").replace(/\*\/\s*$/, "").replace(/^\s*\*\s?/gm, "").trim();
+  }
+  return result;
+}
+function jsdocCommentToString(comment) {
+  if (!comment) return "";
+  if (typeof comment === "string") return comment;
+  return comment.map((c) => c.text ?? "").join("");
+}
+function mapEvents() {
+  return [];
+}
+function mapSlots() {
+  return [];
+}
+var DEFAULT_ADAPTER_VERSION = "0.1.0";
+var MAX_UNWRAP_DEPTH = 6;
+function extractUcfsForReact(opts) {
+  const adapterVersion = opts.adapterVersion ?? DEFAULT_ADAPTER_VERSION;
+  const cwd = opts.cwd ?? process.cwd();
+  const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const sources = collectSources(opts);
+  if (sources.length === 0) return [];
+  const program = createProgram(sources, opts.tsconfig, cwd);
+  const checker = program.getTypeChecker();
+  const results = [];
+  for (const source of sources) {
+    const sourceFile = program.getSourceFile(source.filePath);
+    if (!sourceFile) {
+      console.warn(`[ucf-adapter] skip: cannot load ${source.filePath}`);
+      continue;
+    }
+    try {
+      const facts = extractFromFile({
+        sourceFile,
+        checker,
+        sourceCommit: opts.sourceCommit,
+        adapterVersion,
+        capturedAt,
+        cwd
+      });
+      results.push(...facts);
+    } catch (err) {
+      console.warn(
+        `[ucf-adapter] error processing ${source.filePath}: ${err.message}`
+      );
+    }
+  }
+  return results;
+}
+function collectSources(opts) {
+  const map = /* @__PURE__ */ new Map();
+  for (const filePath of opts.sourceFiles ?? []) {
+    const abs = resolve4(filePath);
+    if (!existsSync4(abs)) continue;
+    map.set(abs, { filePath: abs });
+  }
+  for (const inline of opts.inlineSources ?? []) {
+    const abs = isAbsolute(inline.filePath) ? inline.filePath : resolve4(inline.filePath);
+    map.set(abs, { filePath: abs, inlineSource: inline.source });
+  }
+  return [...map.values()];
+}
+function createProgram(sources, tsconfigPath, cwd) {
+  const options = resolveCompilerOptions(tsconfigPath, cwd);
+  const overlays = /* @__PURE__ */ new Map();
+  for (const { filePath, inlineSource } of sources) {
+    if (inlineSource === void 0) continue;
+    overlays.set(
+      filePath,
+      ts4.createSourceFile(filePath, inlineSource, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TSX)
+    );
+  }
+  const baseHost = ts4.createCompilerHost(options, true);
+  const host = {
+    ...baseHost,
+    getSourceFile: (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+      const overlay = overlays.get(resolve4(fileName));
+      if (overlay) return overlay;
+      return baseHost.getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+    },
+    fileExists: (fileName) => overlays.has(resolve4(fileName)) || baseHost.fileExists(fileName),
+    readFile: (fileName) => {
+      const overlay = overlays.get(resolve4(fileName));
+      if (overlay) return overlay.getFullText();
+      return baseHost.readFile(fileName);
+    },
+    writeFile: () => void 0
+  };
+  return ts4.createProgram({
+    rootNames: sources.map((s) => s.filePath),
+    options,
+    host
+  });
+}
+function resolveCompilerOptions(tsconfigPath, cwd) {
+  if (tsconfigPath && existsSync4(tsconfigPath)) {
+    const resolved = resolve4(tsconfigPath);
+    const configFile = ts4.readConfigFile(resolved, ts4.sys.readFile);
+    if (!configFile.error) {
+      const parsed = ts4.parseJsonConfigFileContent(
+        configFile.config,
+        ts4.sys,
+        dirname4(resolved),
+        void 0,
+        resolved
+      );
+      return parsed.options;
+    }
+  }
+  return {
+    target: ts4.ScriptTarget.ES2022,
+    module: ts4.ModuleKind.ESNext,
+    moduleResolution: ts4.ModuleResolutionKind.Bundler,
+    jsx: ts4.JsxEmit.ReactJSX,
+    allowSyntheticDefaultImports: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    strict: false,
+    noEmit: true,
+    rootDir: cwd
+  };
+}
+function extractFromFile(ctx) {
+  const { sourceFile, checker } = ctx;
+  const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+  const exportSymbols = moduleSymbol ? checker.getExportsOfModule(moduleSymbol) : [];
+  if (exportSymbols.length === 0) return [];
+  const filePath = toRelativePath(sourceFile.fileName, ctx.cwd);
+  const imports = mapImports(sourceFile);
+  const fileExports = mapFileExports(sourceFile);
+  const compoundMap = mapFileCompoundChildren(sourceFile);
+  const style = mapStyleSystem(sourceFile, imports);
+  const facts = [];
+  for (const exportSymbol of exportSymbols) {
+    const name = exportSymbol.getName();
+    if (!isLikelyComponent(name)) continue;
+    const declaration = resolveDeclaration(exportSymbol, checker);
+    if (!declaration) continue;
+    const definition = mapDefinitionKind(declaration);
+    if (!definition.inner) continue;
+    const rootResult = mapRootElements(definition.inner);
+    const aria = mapAria(rootResult.rootElements);
+    const props = mapProps(definition.inner, checker);
+    const behavior = mapBehaviorHints(definition.inner, props);
+    const docs = mapJsdoc(declaration, sourceFile);
+    facts.push({
+      id: ucfId(filePath, name, "react", ctx.sourceCommit),
+      filePath,
+      componentName: name,
+      framework: "react",
+      sourceCommit: ctx.sourceCommit,
+      capturedAt: ctx.capturedAt,
+      adapterVersion: ctx.adapterVersion,
+      definitionKind: definition.kind,
+      wrappedBy: definition.wrappedBy,
+      imports,
+      exports: buildExportRecords(fileExports.exportNames, name),
+      exportedFromBarrel: fileExports.exportedFromBarrel,
+      rootElements: rootResult.rootElements,
+      rootElementsTruncated: rootResult.rootElementsTruncated,
+      ariaRoles: aria.ariaRoles,
+      ariaAttributes: aria.ariaAttributes,
+      props,
+      events: mapEvents(),
+      slots: mapSlots(),
+      hasInternalState: behavior.hasInternalState,
+      hasEffects: behavior.hasEffects,
+      isControlled: behavior.isControlled,
+      compoundChildren: compoundMap.get(name) ?? [],
+      styleSystem: style.styleSystem,
+      classNamesUsed: style.classNamesUsed,
+      jsdocDescription: docs.jsdocDescription,
+      fileHeaderComment: docs.fileHeaderComment
+    });
+  }
+  return facts;
+}
+function buildExportRecords(names, primaryName) {
+  return names.map((exportedAs) => ({ exportedAs, isPrimary: exportedAs === primaryName }));
+}
+function isLikelyComponent(name) {
+  return /^[A-Z][A-Za-z0-9_]*$/.test(name);
+}
+function resolveDeclaration(symbol, checker) {
+  let target = symbol;
+  if (target.flags & ts4.SymbolFlags.Alias) {
+    target = checker.getAliasedSymbol(target);
+  }
+  const decls = target.getDeclarations();
+  if (!decls || decls.length === 0) return null;
+  const decl = decls[0];
+  if (ts4.isVariableDeclaration(decl) && decl.initializer) {
+    return unwrapToComponentNode(decl.initializer, checker);
+  }
+  if (ts4.isFunctionDeclaration(decl)) return decl;
+  if (ts4.isClassDeclaration(decl)) return decl;
+  if (ts4.isExportAssignment(decl)) return unwrapToComponentNode(decl.expression, checker);
+  return null;
+}
+function unwrapToComponentNode(expression, checker) {
+  let cursor = expression;
+  for (let depth = 0; depth < MAX_UNWRAP_DEPTH; depth++) {
+    if (ts4.isCallExpression(cursor) && ts4.isPropertyAccessExpression(cursor.expression) && ts4.isIdentifier(cursor.expression.expression) && cursor.expression.expression.text === "Object" && cursor.expression.name.text === "assign" && cursor.arguments[0]) {
+      cursor = cursor.arguments[0];
+      continue;
+    }
+    if (ts4.isIdentifier(cursor)) {
+      const sym = checker.getSymbolAtLocation(cursor);
+      if (!sym) break;
+      const followed = sym.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
+      const decl = followed.getDeclarations()?.[0];
+      if (decl && ts4.isFunctionDeclaration(decl)) return decl;
+      if (decl && ts4.isClassDeclaration(decl)) return decl;
+      if (decl && ts4.isVariableDeclaration(decl) && decl.initializer) {
+        cursor = decl.initializer;
+        continue;
+      }
+      break;
+    }
+    break;
+  }
+  return cursor;
+}
+function toRelativePath(filePath, cwd) {
+  const rel = relative(cwd, filePath);
+  return rel.startsWith("..") ? filePath : rel;
+}
 export {
   DEFAULT_RECOGNIZED_CLASS_HELPERS,
   aggregateComponentUsage,
@@ -60248,11 +60950,13 @@ export {
   extractClassnameSpreadFact,
   extractCustomPropsFromComponentFile,
   extractJsxFacts,
+  extractUcfsForReact,
   parseClass,
   resolveComponentSourcePath,
   resolveRecognizedHelpers,
   resolveTailwindToken,
   resolveTailwindTokenFacts,
-  resolveTokensWithSass
+  resolveTokensWithSass,
+  ucfId
 };
-//# sourceMappingURL=dist-BDWAHJ4K.js.map
+//# sourceMappingURL=dist-TTCI6TME.js.map