@fragments-sdk/mcp 0.5.18 → 0.6.1

package/dist/dist-V7D67NXS.js

@@ -0,0 +1,1093 @@
+import "./chunk-VRPDT3Y6.js";
+
+// ../extract/dist/index.js
+import { createRequire as __banner_createRequire } from "module";
+import ts from "typescript";
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { dirname as dirname2, extname, join as join2, resolve as resolve2 } from "path";
+import ts2 from "typescript";
+import { resolve as resolve3, dirname as dirname3, basename } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
+var require2 = __banner_createRequire(import.meta.url);
+function createComponentExtractor(tsconfigPath) {
+  let projectVersion = 0;
+  const fileVersions = /* @__PURE__ */ new Map();
+  const fileSnapshots = /* @__PURE__ */ new Map();
+  const rootDir = tsconfigPath ? dirname(resolve(tsconfigPath)) : process.cwd();
+  const parsedCommandLine = tsconfigPath ? parseTsConfig(tsconfigPath) : inferCompilerOptions(rootDir);
+  const scriptFileNames = new Set(parsedCommandLine.fileNames);
+  const host = {
+    getProjectVersion: () => projectVersion.toString(),
+    getScriptVersion: (fileName) => (fileVersions.get(fileName) ?? 0).toString(),
+    getScriptSnapshot: (fileName) => {
+      const cached = fileSnapshots.get(fileName);
+      if (cached) return cached;
+      let text;
+      try {
+        text = readFileSync(fileName, "utf-8");
+      } catch {
+        return void 0;
+      }
+      const snapshot = ts.ScriptSnapshot.fromString(text);
+      fileSnapshots.set(fileName, snapshot);
+      return snapshot;
+    },
+    getScriptFileNames: () => [...scriptFileNames],
+    getCompilationSettings: () => parsedCommandLine.options,
+    getCurrentDirectory: () => rootDir,
+    getDefaultLibFileName: ts.getDefaultLibFilePath,
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories,
+    resolveModuleNames: (moduleNames, containingFile) => moduleNames.map((moduleName) => {
+      const resolved = ts.resolveModuleName(
+        moduleName,
+        containingFile,
+        parsedCommandLine.options,
+        {
+          fileExists: ts.sys.fileExists,
+          readFile: ts.sys.readFile,
+          realpath: ts.sys.realpath,
+          directoryExists: ts.sys.directoryExists,
+          getDirectories: ts.sys.getDirectories,
+          getCurrentDirectory: () => rootDir
+        }
+      );
+      return resolved.resolvedModule;
+    })
+  };
+  const languageService = ts.createLanguageService(host, ts.createDocumentRegistry());
+  function ensureFile(filePath) {
+    const resolved = resolve(filePath);
+    if (!scriptFileNames.has(resolved)) {
+      scriptFileNames.add(resolved);
+      projectVersion++;
+    }
+  }
+  function getChecker() {
+    const program = languageService.getProgram();
+    if (!program) throw new Error("Failed to get program from LanguageService");
+    return program.getTypeChecker();
+  }
+  function getSourceFile(filePath) {
+    return languageService.getProgram()?.getSourceFile(resolve(filePath));
+  }
+  return {
+    extract(filePath, exportName) {
+      const resolved = resolve(filePath);
+      ensureFile(resolved);
+      const sourceFile = getSourceFile(resolved);
+      if (!sourceFile) return null;
+      const checker = getChecker();
+      const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return null;
+      const exports = checker.getExportsOfModule(moduleSymbol);
+      const targetName = exportName ?? findPrimaryExport(exports, sourceFile);
+      if (!targetName) return null;
+      const exportSymbol = exports.find((s) => s.getName() === targetName);
+      if (!exportSymbol) return null;
+      const component = resolveExportedComponent(checker, exportSymbol, sourceFile);
+      if (!component) return null;
+      return buildComponentMeta(checker, component, resolved, sourceFile, exports);
+    },
+    extractAll(filePath) {
+      const resolved = resolve(filePath);
+      ensureFile(resolved);
+      const sourceFile = getSourceFile(resolved);
+      if (!sourceFile) return [];
+      const checker = getChecker();
+      const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return [];
+      const exports = checker.getExportsOfModule(moduleSymbol);
+      const results = [];
+      for (const exportSymbol of exports) {
+        const name = exportSymbol.getName();
+        if (!/^[A-Z]/.test(name)) continue;
+        const component = resolveExportedComponent(checker, exportSymbol, sourceFile);
+        if (!component) continue;
+        const meta = buildComponentMeta(checker, component, resolved, sourceFile, exports);
+        if (meta) results.push(meta);
+      }
+      return results;
+    },
+    invalidate(filePath) {
+      const resolved = resolve(filePath);
+      fileVersions.set(resolved, (fileVersions.get(resolved) ?? 0) + 1);
+      fileSnapshots.delete(resolved);
+      projectVersion++;
+    },
+    dispose() {
+      languageService.dispose();
+      fileSnapshots.clear();
+      fileVersions.clear();
+    }
+  };
+}
+function parseTsConfig(tsconfigPath) {
+  const resolved = resolve(tsconfigPath);
+  const configFile = ts.readConfigFile(resolved, ts.sys.readFile);
+  if (configFile.error) {
+    throw new Error(`Failed to read tsconfig: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`);
+  }
+  return ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    dirname(resolved),
+    void 0,
+    resolved
+  );
+}
+function inferCompilerOptions(rootDir) {
+  return {
+    options: {
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      jsx: ts.JsxEmit.ReactJSX,
+      allowSyntheticDefaultImports: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      strict: false,
+      noEmit: true
+    },
+    fileNames: [],
+    errors: []
+  };
+}
+function findPrimaryExport(exports, sourceFile) {
+  const defaultExport = exports.find((s) => s.getName() === "default");
+  if (defaultExport) return "default";
+  for (const s of exports) {
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(s.getName())) {
+      return s.getName();
+    }
+  }
+  return null;
+}
+function resolveExportedComponent(checker, exportSymbol, sourceFile) {
+  const name = exportSymbol.getName();
+  let symbol = exportSymbol;
+  if (symbol.flags & ts.SymbolFlags.Alias) {
+    symbol = checker.getAliasedSymbol(symbol);
+  }
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0) return null;
+  const declaration = declarations[0];
+  if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+    return resolveFromExpression(checker, name, declaration.initializer, declaration, sourceFile);
+  }
+  if (ts.isFunctionDeclaration(declaration)) {
+    const propsType = extractPropsFromFunctionLike(checker, declaration);
+    return propsType ? { name, propsType, componentNode: declaration, compoundParts: null } : null;
+  }
+  if (ts.isExportAssignment(declaration) && declaration.expression) {
+    return resolveFromExpression(checker, name, declaration.expression, null, sourceFile);
+  }
+  return null;
+}
+function resolveFromExpression(checker, name, expression, variableDecl, sourceFile) {
+  expression = unwrapExpression(expression);
+  if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+    const propsType = extractPropsFromFunctionLike(checker, expression);
+    return propsType ? { name, propsType, componentNode: expression, compoundParts: null } : null;
+  }
+  if (ts.isCallExpression(expression)) {
+    return resolveCallExpression(checker, name, expression, variableDecl, sourceFile);
+  }
+  if (ts.isIdentifier(expression)) {
+    const sym = checker.getSymbolAtLocation(expression);
+    if (sym) {
+      const decls = sym.getDeclarations();
+      if (decls && decls.length > 0) {
+        const decl = decls[0];
+        if (ts.isVariableDeclaration(decl) && decl.initializer) {
+          return resolveFromExpression(checker, name, decl.initializer, decl, sourceFile);
+        }
+        if (ts.isFunctionDeclaration(decl)) {
+          const propsType = extractPropsFromFunctionLike(checker, decl);
+          return propsType ? { name, propsType, componentNode: decl, compoundParts: null } : null;
+        }
+      }
+    }
+  }
+  if (variableDecl?.type && ts.isTypeReferenceNode(variableDecl.type)) {
+    const typeName = variableDecl.type.typeName.getText(sourceFile);
+    if (typeName.includes("FC") || typeName.includes("FunctionComponent")) {
+      const typeArg = variableDecl.type.typeArguments?.[0];
+      if (typeArg) {
+        const propsType = checker.getTypeFromTypeNode(typeArg);
+        return { name, propsType, componentNode: expression, compoundParts: null };
+      }
+    }
+  }
+  return null;
+}
+function resolveCallExpression(checker, name, call, variableDecl, sourceFile) {
+  const callee = call.expression;
+  if (isObjectAssignCall(callee, sourceFile)) {
+    return resolveObjectAssign(checker, name, call, sourceFile);
+  }
+  if (isForwardRefCall(callee)) {
+    return resolveForwardRef(checker, name, call, sourceFile);
+  }
+  if (isMemoCall(callee)) {
+    const innerArg = call.arguments[0];
+    if (innerArg) {
+      return resolveFromExpression(checker, name, innerArg, variableDecl, sourceFile);
+    }
+  }
+  return null;
+}
+function resolveObjectAssign(checker, name, call, sourceFile) {
+  if (call.arguments.length < 2) return null;
+  const rootExpr = call.arguments[0];
+  const rootResult = resolveFromExpression(checker, name, rootExpr, null, sourceFile);
+  const subsArg = call.arguments[1];
+  const compoundParts = /* @__PURE__ */ new Map();
+  if (ts.isObjectLiteralExpression(subsArg)) {
+    for (const prop of subsArg.properties) {
+      let subName = null;
+      let subExpression = null;
+      if (ts.isShorthandPropertyAssignment(prop)) {
+        subName = prop.name.text;
+        const sym = checker.getSymbolAtLocation(prop.name);
+        if (sym) {
+          const subPropsType = extractPropsFromComponentSymbol(checker, sym);
+          if (subPropsType) {
+            compoundParts.set(subName, subPropsType);
+          }
+        }
+      } else if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+        subName = prop.name.text;
+        subExpression = prop.initializer;
+        if (subExpression) {
+          const subType = extractPropsFromExpression(checker, subExpression, sourceFile);
+          if (subType) {
+            compoundParts.set(subName, subType);
+          }
+        }
+      }
+    }
+  }
+  return {
+    name,
+    propsType: rootResult?.propsType ?? null,
+    componentNode: rootResult?.componentNode ?? rootExpr,
+    compoundParts: compoundParts.size > 0 ? compoundParts : null
+  };
+}
+function extractPropsFromComponentSymbol(checker, symbol) {
+  let sym = symbol;
+  if (sym.flags & ts.SymbolFlags.Alias) {
+    sym = checker.getAliasedSymbol(sym);
+  }
+  const decls = sym.getDeclarations();
+  if (!decls || decls.length === 0) return null;
+  const decl = decls[0];
+  if (ts.isFunctionDeclaration(decl)) {
+    return extractPropsFromFunctionLike(checker, decl);
+  }
+  if (ts.isVariableDeclaration(decl) && decl.initializer) {
+    return extractPropsFromExpressionDeep(checker, decl);
+  }
+  return null;
+}
+function extractPropsFromExpression(checker, expr, sourceFile) {
+  expr = unwrapExpression(expr);
+  if (ts.isIdentifier(expr)) {
+    const sym = checker.getSymbolAtLocation(expr);
+    if (sym) return extractPropsFromComponentSymbol(checker, sym);
+  }
+  if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
+    return extractPropsFromFunctionLike(checker, expr);
+  }
+  if (ts.isCallExpression(expr)) {
+    if (isForwardRefCall(expr.expression)) {
+      const typeArg = expr.typeArguments?.[1];
+      if (typeArg) return checker.getTypeFromTypeNode(typeArg);
+      const innerArg = expr.arguments[0];
+      if (innerArg && (ts.isArrowFunction(innerArg) || ts.isFunctionExpression(innerArg))) {
+        return extractPropsFromFunctionLike(checker, innerArg);
+      }
+    }
+    if (isMemoCall(expr.expression) && expr.arguments[0]) {
+      return extractPropsFromExpression(checker, expr.arguments[0], sourceFile);
+    }
+  }
+  return null;
+}
+function extractPropsFromExpressionDeep(checker, decl) {
+  if (!decl.initializer) return null;
+  const expr = unwrapExpression(decl.initializer);
+  if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
+    return extractPropsFromFunctionLike(checker, expr);
+  }
+  if (ts.isCallExpression(expr)) {
+    if (isForwardRefCall(expr.expression)) {
+      const typeArg = expr.typeArguments?.[1];
+      if (typeArg) return checker.getTypeFromTypeNode(typeArg);
+      const innerArg = expr.arguments[0];
+      if (innerArg && (ts.isArrowFunction(innerArg) || ts.isFunctionExpression(innerArg))) {
+        return extractPropsFromFunctionLike(checker, innerArg);
+      }
+    }
+    if (isMemoCall(expr.expression) && expr.arguments[0]) {
+      return extractPropsFromExpressionDeep(checker, {
+        ...decl,
+        initializer: expr.arguments[0]
+      });
+    }
+  }
+  return null;
+}
+function resolveForwardRef(checker, name, call, sourceFile) {
+  const propsTypeArg = call.typeArguments?.[1];
+  if (propsTypeArg) {
+    const propsType = checker.getTypeFromTypeNode(propsTypeArg);
+    const innerArg2 = call.arguments[0];
+    const componentNode = innerArg2 && (ts.isArrowFunction(innerArg2) || ts.isFunctionExpression(innerArg2)) ? innerArg2 : null;
+    return { name, propsType, componentNode, compoundParts: null };
+  }
+  const innerArg = call.arguments[0];
+  if (innerArg) {
+    if (ts.isArrowFunction(innerArg) || ts.isFunctionExpression(innerArg)) {
+      const propsType = extractPropsFromFunctionLike(checker, innerArg);
+      return propsType ? { name, propsType, componentNode: innerArg, compoundParts: null } : null;
+    }
+    if (ts.isIdentifier(innerArg)) {
+      const sym = checker.getSymbolAtLocation(innerArg);
+      if (sym) {
+        const propsType = extractPropsFromComponentSymbol(checker, sym);
+        if (propsType) return { name, propsType, componentNode: innerArg, compoundParts: null };
+      }
+    }
+  }
+  return null;
+}
+function extractPropsFromFunctionLike(checker, func) {
+  const firstParam = func.parameters[0];
+  if (!firstParam) return null;
+  if (firstParam.type) {
+    const directType = checker.getTypeFromTypeNode(firstParam.type);
+    if (checker.getPropertiesOfType(directType).length > 0) {
+      return directType;
+    }
+    const apparentType = checker.getApparentType(directType);
+    if (checker.getPropertiesOfType(apparentType).length > 0) {
+      return apparentType;
+    }
+    const paramType = checker.getTypeAtLocation(firstParam);
+    if (checker.getPropertiesOfType(paramType).length > 0) {
+      return paramType;
+    }
+    const constrainedType = checker.getBaseConstraintOfType(directType);
+    if (constrainedType && checker.getPropertiesOfType(constrainedType).length > 0) {
+      return constrainedType;
+    }
+    return directType;
+  }
+  const paramSymbol = checker.getSymbolAtLocation(firstParam.name);
+  if (paramSymbol) {
+    return checker.getTypeOfSymbolAtLocation(paramSymbol, firstParam);
+  }
+  return null;
+}
+function buildComponentMeta(checker, component, filePath, sourceFile, moduleExports) {
+  const props = {};
+  const sourceFilePath = toPosixPath(sourceFile.fileName);
+  if (component.propsType) {
+    extractPropsFromType(checker, component.propsType, props, sourceFilePath);
+    if (Object.keys(props).length === 0) {
+      const apparentPropsType = checker.getApparentType(component.propsType);
+      if (apparentPropsType !== component.propsType) {
+        extractPropsFromType(checker, apparentPropsType, props, sourceFilePath);
+      }
+    }
+    if (Object.keys(props).length === 0) {
+      const constrainedPropsType = checker.getBaseConstraintOfType(component.propsType);
+      if (constrainedPropsType) {
+        extractPropsFromType(checker, constrainedPropsType, props, sourceFilePath);
+      }
+    }
+  }
+  const destructuredProps = component.componentNode ? extractDestructuredPropNames(component.componentNode) : /* @__PURE__ */ new Set();
+  for (const propName of destructuredProps) {
+    if (props[propName]) {
+      props[propName].source = "local";
+    }
+  }
+  const defaults = component.componentNode ? extractDefaultValues(component.componentNode) : {};
+  for (const [propName, defaultVal] of Object.entries(defaults)) {
+    if (props[propName]) {
+      props[propName].default = defaultVal;
+    }
+  }
+  let composition = null;
+  if (component.compoundParts && component.compoundParts.size > 0) {
+    const parts = [];
+    for (const [partName, partType] of component.compoundParts) {
+      const partProps = {};
+      extractPropsFromType(checker, partType, partProps, sourceFilePath);
+      parts.push({ name: partName, props: partProps });
+    }
+    composition = {
+      pattern: "compound",
+      parts,
+      required: []
+      // Could be inferred from usage patterns
+    };
+  }
+  let description = "";
+  const componentSymbol = moduleExports.find((s) => s.getName() === component.name);
+  if (componentSymbol) {
+    description = extractJSDocDescription(checker, componentSymbol);
+  }
+  const exportNames = moduleExports.filter((s) => /^[A-Z]/.test(s.getName())).map((s) => s.getName());
+  const dependencies = extractDependencies(sourceFile);
+  return {
+    name: component.name,
+    filePath,
+    description,
+    props,
+    composition,
+    exports: exportNames,
+    dependencies
+  };
+}
+function extractPropsFromType(checker, propsType, result, sourceFilePath) {
+  for (const symbol of checker.getPropertiesOfType(propsType)) {
+    const propName = symbol.getName();
+    if (propName.startsWith("_") || propName.startsWith("$")) continue;
+    if (propName === "key" || propName === "ref") continue;
+    const declarations = symbol.getDeclarations() ?? [];
+    const isLocal = declarations.some(
+      (d) => toPosixPath(d.getSourceFile().fileName) === sourceFilePath
+    );
+    const referenceNode = declarations[0];
+    if (!referenceNode) continue;
+    const propType = checker.getTypeOfSymbolAtLocation(symbol, referenceNode);
+    const serialized = serializePropType(checker, propType);
+    const description = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    const required = (symbol.flags & ts.SymbolFlags.Optional) === 0;
+    let jsDocDefault;
+    const jsDocTags = symbol.getJsDocTags(checker);
+    const defaultTag = jsDocTags.find((t) => t.name === "default");
+    if (defaultTag?.text) {
+      jsDocDefault = ts.displayPartsToString(defaultTag.text).trim();
+    }
+    result[propName] = {
+      name: propName,
+      type: serialized.type,
+      typeKind: serialized.typeKind,
+      values: serialized.values,
+      default: jsDocDefault,
+      description: description || void 0,
+      required,
+      source: isLocal ? "local" : "inherited"
+    };
+  }
+}
+function serializePropType(checker, type) {
+  const aliasSymbol = type.aliasSymbol;
+  if (aliasSymbol) {
+    const aliasName = aliasSymbol.getName();
+    if (aliasName === "ReactNode") {
+      return { type: "ReactNode", typeKind: "node" };
+    }
+    if (aliasName === "ReactElement") {
+      return { type: "ReactElement", typeKind: "element" };
+    }
+  }
+  if (type.isUnion()) {
+    const nonNullableTypes = type.types.filter(
+      (t) => !(t.flags & ts.TypeFlags.Undefined || t.flags & ts.TypeFlags.Null || t.flags & ts.TypeFlags.Void)
+    );
+    if (nonNullableTypes.length === 1) {
+      return serializePropType(checker, nonNullableTypes[0]);
+    }
+    if (nonNullableTypes.length > 0 && nonNullableTypes.every((t) => t.isStringLiteral())) {
+      const values = nonNullableTypes.map((t) => t.value);
+      return {
+        type: values.map((v) => `"${v}"`).join(" | "),
+        typeKind: "enum",
+        values
+      };
+    }
+    if (nonNullableTypes.every((t) => isBooleanLike(t))) {
+      return { type: "boolean", typeKind: "boolean" };
+    }
+    const typeStr2 = checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+    return { type: typeStr2, typeKind: "union" };
+  }
+  const typeStr = checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+  if (typeStr.includes("ReactNode")) {
+    return { type: "ReactNode", typeKind: "node" };
+  }
+  if (typeStr.includes("ReactElement") || typeStr.includes("JSX.Element")) {
+    return { type: "ReactElement", typeKind: "element" };
+  }
+  if (type.getCallSignatures().length > 0) {
+    return { type: typeStr, typeKind: "function" };
+  }
+  if (type.flags & ts.TypeFlags.String) return { type: "string", typeKind: "string" };
+  if (type.flags & ts.TypeFlags.Number) return { type: "number", typeKind: "number" };
+  if (type.flags & ts.TypeFlags.Boolean || type.flags & ts.TypeFlags.BooleanLiteral) {
+    return { type: "boolean", typeKind: "boolean" };
+  }
+  if (type.isStringLiteral()) {
+    return { type: `"${type.value}"`, typeKind: "enum", values: [type.value] };
+  }
+  if (checker.isArrayType(type) || checker.isTupleType(type)) {
+    return { type: typeStr, typeKind: "array" };
+  }
+  if (type.flags & ts.TypeFlags.Object) {
+    return { type: typeStr, typeKind: "object" };
+  }
+  return { type: typeStr, typeKind: "custom" };
+}
+function extractDefaultValues(node) {
+  const defaults = {};
+  let funcNode = null;
+  if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    funcNode = node;
+  }
+  if (!funcNode?.parameters?.length) return defaults;
+  const firstParam = funcNode.parameters[0];
+  if (!ts.isObjectBindingPattern(firstParam.name)) return defaults;
+  for (const element of firstParam.name.elements) {
+    let propName = null;
+    if (element.propertyName) {
+      if (ts.isIdentifier(element.propertyName) || ts.isStringLiteral(element.propertyName)) {
+        propName = element.propertyName.text;
+      }
+    } else if (ts.isIdentifier(element.name)) {
+      propName = element.name.text;
+    }
+    if (!propName || !element.initializer) continue;
+    const value = readLiteralValue(element.initializer);
+    if (value !== void 0) {
+      defaults[propName] = value;
+    }
+  }
+  return defaults;
+}
+function extractDestructuredPropNames(node) {
+  const names = /* @__PURE__ */ new Set();
+  let funcNode = null;
+  if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    funcNode = node;
+  }
+  if (!funcNode?.parameters?.length) return names;
+  const firstParam = funcNode.parameters[0];
+  if (!ts.isObjectBindingPattern(firstParam.name)) return names;
+  for (const element of firstParam.name.elements) {
+    if (element.dotDotDotToken || !ts.isIdentifier(element.name)) continue;
+    const propName = element.propertyName ? element.propertyName.getText() : element.name.text;
+    if (propName === "className" || propName === "children" || propName === "ref") {
+      continue;
+    }
+    names.add(propName);
+  }
+  return names;
+}
+function readLiteralValue(expression) {
+  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts.isNumericLiteral(expression)) {
+    return expression.text;
+  }
+  if (expression.kind === ts.SyntaxKind.TrueKeyword) return "true";
+  if (expression.kind === ts.SyntaxKind.FalseKeyword) return "false";
+  if (expression.kind === ts.SyntaxKind.NullKeyword) return "null";
+  if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(expression.operand)) {
+    return `-${expression.operand.text}`;
+  }
+  return void 0;
+}
+function extractJSDocDescription(checker, symbol) {
+  let sym = symbol;
+  if (sym.flags & ts.SymbolFlags.Alias) {
+    sym = checker.getAliasedSymbol(sym);
+  }
+  const docComment = ts.displayPartsToString(sym.getDocumentationComment(checker)).trim();
+  if (docComment) return docComment;
+  const decls = sym.getDeclarations();
+  if (decls) {
+    for (const decl of decls) {
+      const sourceFile = decl.getSourceFile();
+      for (const stmt of sourceFile.statements) {
+        if ((ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) && stmt.name.text === `${symbol.getName()}Props`) {
+          const propsDoc = ts.displayPartsToString(
+            checker.getSymbolAtLocation(stmt.name)?.getDocumentationComment(checker) ?? []
+          ).trim();
+          if (propsDoc) return propsDoc;
+        }
+      }
+    }
+  }
+  return "";
+}
+function extractDependencies(sourceFile) {
+  const deps = [];
+  for (const stmt of sourceFile.statements) {
+    if (!ts.isImportDeclaration(stmt)) continue;
+    if (!ts.isStringLiteral(stmt.moduleSpecifier)) continue;
+    const modulePath = stmt.moduleSpecifier.text;
+    if (!modulePath.startsWith(".") && !modulePath.startsWith("/")) continue;
+    const clause = stmt.importClause;
+    if (!clause) continue;
+    if (clause.name && /^[A-Z]/.test(clause.name.text)) {
+      deps.push(clause.name.text);
+    }
+    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+      for (const element of clause.namedBindings.elements) {
+        if (/^[A-Z]/.test(element.name.text)) {
+          deps.push(element.name.text);
+        }
+      }
+    }
+  }
+  return deps;
+}
+function unwrapExpression(expr) {
+  while (true) {
+    if (ts.isParenthesizedExpression(expr)) {
+      expr = expr.expression;
+    } else if (ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr)) {
+      expr = expr.expression;
+    } else {
+      return expr;
+    }
+  }
+}
+function isObjectAssignCall(callee, sourceFile) {
+  if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "Object" && callee.name.text === "assign") {
+    return true;
+  }
+  return false;
+}
+function isForwardRefCall(callee) {
+  if (ts.isPropertyAccessExpression(callee) && callee.name.text === "forwardRef") {
+    return true;
+  }
+  if (ts.isIdentifier(callee) && callee.text === "forwardRef") {
+    return true;
+  }
+  return false;
+}
+function isMemoCall(callee) {
+  if (ts.isPropertyAccessExpression(callee) && callee.name.text === "memo") {
+    return true;
+  }
+  if (ts.isIdentifier(callee) && callee.text === "memo") {
+    return true;
+  }
+  return false;
+}
+function isBooleanLike(type) {
+  return (type.flags & ts.TypeFlags.BooleanLike) !== 0 || type.flags === ts.TypeFlags.BooleanLiteral;
+}
+function toPosixPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function toPosixPath2(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function isFile(filePath) {
+  if (!existsSync2(filePath)) return false;
+  try {
+    return statSync2(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveModulePath(basePath) {
+  const candidates = [];
+  const extension = extname(basePath);
+  if (extension) {
+    candidates.push(basePath);
+  } else {
+    candidates.push(
+      `${basePath}.tsx`,
+      `${basePath}.ts`,
+      `${basePath}.jsx`,
+      `${basePath}.js`,
+      join2(basePath, "index.tsx"),
+      join2(basePath, "index.ts"),
+      join2(basePath, "index.jsx"),
+      join2(basePath, "index.js")
+    );
+  }
+  for (const candidate of candidates) {
+    if (isFile(candidate)) {
+      return resolve2(candidate);
+    }
+  }
+  return null;
+}
+function resolveComponentSourcePath(fragmentFileAbsolutePath, componentImportPath) {
+  if (!componentImportPath) return null;
+  if (!componentImportPath.startsWith(".")) return null;
+  const fragmentDir = dirname2(fragmentFileAbsolutePath);
+  const basePath = resolve2(fragmentDir, componentImportPath);
+  return resolveModulePath(basePath);
+}
+function collectTopLevelDeclarations(sourceFile) {
+  const typeDeclarations = /* @__PURE__ */ new Map();
+  const functionDeclarations = /* @__PURE__ */ new Map();
+  const variableDeclarations = /* @__PURE__ */ new Map();
+  for (const node of sourceFile.statements) {
+    if (ts2.isInterfaceDeclaration(node)) {
+      typeDeclarations.set(node.name.text, node);
+      continue;
+    }
+    if (ts2.isTypeAliasDeclaration(node)) {
+      typeDeclarations.set(node.name.text, node);
+      continue;
+    }
+    if (ts2.isFunctionDeclaration(node) && node.name) {
+      functionDeclarations.set(node.name.text, node);
+      continue;
+    }
+    if (ts2.isVariableStatement(node)) {
+      for (const declaration of node.declarationList.declarations) {
+        if (ts2.isIdentifier(declaration.name)) {
+          variableDeclarations.set(declaration.name.text, declaration);
+        }
+      }
+    }
+  }
+  return { typeDeclarations, functionDeclarations, variableDeclarations };
+}
+function readDefaultValue(expression) {
+  if (ts2.isStringLiteral(expression) || ts2.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts2.isNumericLiteral(expression)) {
+    return Number(expression.text);
+  }
+  if (expression.kind === ts2.SyntaxKind.TrueKeyword) return true;
+  if (expression.kind === ts2.SyntaxKind.FalseKeyword) return false;
+  if (expression.kind === ts2.SyntaxKind.NullKeyword) return null;
+  if (ts2.isPrefixUnaryExpression(expression) && expression.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(expression.operand)) {
+    return -Number(expression.operand.text);
+  }
+  return void 0;
+}
+function extractDefaultValues2(componentNode) {
+  const defaults = {};
+  if (!componentNode?.parameters?.length) return defaults;
+  const firstParam = componentNode.parameters[0];
+  if (!ts2.isObjectBindingPattern(firstParam.name)) return defaults;
+  for (const element of firstParam.name.elements) {
+    let propName = null;
+    if (element.propertyName) {
+      if (ts2.isIdentifier(element.propertyName) || ts2.isStringLiteral(element.propertyName)) {
+        propName = element.propertyName.text;
+      }
+    } else if (ts2.isIdentifier(element.name)) {
+      propName = element.name.text;
+    }
+    if (!propName || !element.initializer) continue;
+    const value = readDefaultValue(element.initializer);
+    if (value !== void 0) {
+      defaults[propName] = value;
+    }
+  }
+  return defaults;
+}
+function isNullishType(type) {
+  return (type.flags & ts2.TypeFlags.Null) !== 0 || (type.flags & ts2.TypeFlags.Undefined) !== 0 || (type.flags & ts2.TypeFlags.Void) !== 0;
+}
+function isBooleanLikeType(type) {
+  return (type.flags & ts2.TypeFlags.BooleanLike) !== 0 || type.flags === ts2.TypeFlags.BooleanLiteral;
+}
+function inferPropType(type, checker) {
+  const typeText = checker.typeToString(type, void 0, ts2.TypeFormatFlags.NoTruncation);
+  if (typeText.includes("ReactNode")) {
+    return { type: "node" };
+  }
+  if (typeText.includes("ReactElement") || typeText.includes("JSX.Element")) {
+    return { type: "element" };
+  }
+  if (type.getCallSignatures().length > 0) {
+    return { type: "function" };
+  }
+  if (checker.isArrayType(type) || checker.isTupleType(type)) {
+    return { type: "array" };
+  }
+  if (type.isUnion()) {
+    const nonNullableTypes = type.types.filter((unionType) => !isNullishType(unionType));
+    if (nonNullableTypes.length === 1) {
+      return inferPropType(nonNullableTypes[0], checker);
+    }
+    const stringLiteralValues = nonNullableTypes.filter((unionType) => (unionType.flags & ts2.TypeFlags.StringLiteral) !== 0).map((unionType) => unionType.value);
+    if (stringLiteralValues.length > 0 && stringLiteralValues.length === nonNullableTypes.length) {
+      return { type: "enum", values: stringLiteralValues };
+    }
+    if (nonNullableTypes.every((unionType) => isBooleanLikeType(unionType))) {
+      return { type: "boolean" };
+    }
+    return { type: "union" };
+  }
+  if ((type.flags & ts2.TypeFlags.StringLike) !== 0) {
+    return { type: "string" };
+  }
+  if ((type.flags & ts2.TypeFlags.NumberLike) !== 0) {
+    return { type: "number" };
+  }
+  if ((type.flags & ts2.TypeFlags.BooleanLike) !== 0) {
+    return { type: "boolean" };
+  }
+  if ((type.flags & ts2.TypeFlags.Object) !== 0) {
+    return { type: "object" };
+  }
+  return { type: "custom" };
+}
+function resolveComponentSignature(exportName, declarations, sourceFile) {
+  const visitedNames = /* @__PURE__ */ new Set();
+  const typeNodeFromFunction = (node) => ({
+    propsTypeNode: node.parameters[0]?.type ?? null,
+    componentNode: node
+  });
+  const resolveFromExpression2 = (expression) => {
+    if (ts2.isParenthesizedExpression(expression)) {
+      return resolveFromExpression2(expression.expression);
+    }
+    if (ts2.isAsExpression(expression) || ts2.isTypeAssertionExpression(expression)) {
+      return resolveFromExpression2(expression.expression);
+    }
+    if (ts2.isArrowFunction(expression) || ts2.isFunctionExpression(expression)) {
+      return typeNodeFromFunction(expression);
+    }
+    if (ts2.isIdentifier(expression)) {
+      return resolveFromIdentifier(expression.text);
+    }
+    if (ts2.isCallExpression(expression)) {
+      if (ts2.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "forwardRef") {
+        const forwardRefPropsType = expression.typeArguments?.[1] ?? null;
+        const innerArg = expression.arguments[0];
+        const inner = innerArg && (ts2.isArrowFunction(innerArg) || ts2.isFunctionExpression(innerArg)) ? typeNodeFromFunction(innerArg) : innerArg && ts2.isIdentifier(innerArg) ? resolveFromIdentifier(innerArg.text) : { propsTypeNode: null, componentNode: null };
+        return {
+          propsTypeNode: forwardRefPropsType ?? inner.propsTypeNode,
+          componentNode: inner.componentNode
+        };
+      }
+      if (ts2.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "memo" && expression.arguments[0]) {
+        return resolveFromExpression2(expression.arguments[0]);
+      }
+      if (ts2.isPropertyAccessExpression(expression.expression) && expression.expression.expression.getText(sourceFile) === "Object" && expression.expression.name.text === "assign" && expression.arguments[0]) {
+        return resolveFromExpression2(expression.arguments[0]);
+      }
+    }
+    return { propsTypeNode: null, componentNode: null };
+  };
+  const resolveFromVariable = (declaration) => {
+    if (declaration.type && ts2.isTypeReferenceNode(declaration.type) && declaration.type.typeArguments?.length) {
+      const typeName = declaration.type.typeName.getText(sourceFile);
+      if (typeName.includes("FC") || typeName.includes("FunctionComponent")) {
+        const componentNode = declaration.initializer && (ts2.isArrowFunction(declaration.initializer) || ts2.isFunctionExpression(declaration.initializer)) ? declaration.initializer : null;
+        return {
+          propsTypeNode: declaration.type.typeArguments[0] ?? null,
+          componentNode
+        };
+      }
+    }
+    if (declaration.initializer) {
+      return resolveFromExpression2(declaration.initializer);
+    }
+    return { propsTypeNode: null, componentNode: null };
+  };
+  const resolveFromIdentifier = (name) => {
+    if (!name || visitedNames.has(name)) {
+      return { propsTypeNode: null, componentNode: null };
+    }
+    visitedNames.add(name);
+    const functionDeclaration = declarations.functionDeclarations.get(name);
+    if (functionDeclaration) {
+      return typeNodeFromFunction(functionDeclaration);
+    }
+    const variableDeclaration = declarations.variableDeclarations.get(name);
+    if (variableDeclaration) {
+      return resolveFromVariable(variableDeclaration);
+    }
+    return { propsTypeNode: null, componentNode: null };
+  };
+  return resolveFromIdentifier(exportName);
+}
+function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
+  const warnings = [];
+  const resolvedPath = resolve2(componentFilePath);
+  if (!existsSync2(resolvedPath)) {
+    return {
+      props: {},
+      warnings: [`Component file not found: ${resolvedPath}`],
+      resolved: false
+    };
+  }
+  const compilerOptions = {
+    target: ts2.ScriptTarget.ESNext,
+    module: ts2.ModuleKind.ESNext,
+    moduleResolution: ts2.ModuleResolutionKind.Bundler,
+    jsx: ts2.JsxEmit.ReactJSX,
+    allowSyntheticDefaultImports: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    strict: false,
+    noEmit: true
+  };
+  const program = ts2.createProgram([resolvedPath], compilerOptions);
+  const sourceFile = program.getSourceFile(resolvedPath);
+  if (!sourceFile) {
+    return {
+      props: {},
+      warnings: [`Unable to parse component source: ${resolvedPath}`],
+      resolved: false
+    };
+  }
+  const checker = program.getTypeChecker();
+  const declarations = collectTopLevelDeclarations(sourceFile);
+  const signature = resolveComponentSignature(exportName, declarations, sourceFile);
+  if (!signature.propsTypeNode) {
+    return {
+      props: {},
+      warnings: [`Unable to resolve props type for export: ${exportName}`],
+      resolved: false
+    };
+  }
+  const propsType = checker.getTypeFromTypeNode(signature.propsTypeNode);
+  const defaultValues = extractDefaultValues2(signature.componentNode);
+  const sourceFilePath = toPosixPath2(sourceFile.fileName);
+  const extractedProps = {};
+  for (const symbol of checker.getPropertiesOfType(propsType)) {
+    const propName = symbol.getName();
+    if (propName.startsWith("_") || propName.startsWith("$")) {
+      continue;
+    }
+    const declarationsForSymbol = symbol.getDeclarations() ?? [];
+    const localDeclarations = declarationsForSymbol.filter(
+      (declaration) => toPosixPath2(declaration.getSourceFile().fileName) === sourceFilePath
+    );
+    if (localDeclarations.length === 0) {
+      continue;
+    }
+    const referenceNode = localDeclarations[0];
+    const inferredType = inferPropType(checker.getTypeOfSymbolAtLocation(symbol, referenceNode), checker);
+    const description = ts2.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    extractedProps[propName] = {
+      type: inferredType.type,
+      description,
+      required: (symbol.getFlags() & ts2.SymbolFlags.Optional) === 0,
+      ...inferredType.values && { values: inferredType.values },
+      ...defaultValues[propName] !== void 0 && { default: defaultValues[propName] }
+    };
+  }
+  if (Object.keys(extractedProps).length === 0) {
+    warnings.push(`Resolved props type for ${exportName}, but no local custom props were found`);
+  }
+  return {
+    props: extractedProps,
+    warnings,
+    resolved: true
+  };
+}
+function roundRgbValues(value) {
+  return value.replace(
+    /rgb\(([^)]+)\)/g,
+    (_full, inner) => {
+      const parts = inner.split(",").map((p) => p.trim());
+      const rounded = parts.map((p) => {
+        const num = parseFloat(p);
+        return isNaN(num) ? p : String(Math.round(num));
+      });
+      return `rgb(${rounded.join(", ")})`;
+    }
+  ).replace(
+    /rgba\(([^)]+)\)/g,
+    (_full, inner) => {
+      const parts = inner.split(",").map((p) => p.trim());
+      const rounded = parts.map((p, i) => {
+        if (i >= 3) return p;
+        const num = parseFloat(p);
+        return isNaN(num) ? p : String(Math.round(num));
+      });
+      return `rgba(${rounded.join(", ")})`;
+    }
+  );
+}
+async function resolveTokensWithSass(unresolvedTokens, tokensDir) {
+  const resolvedMap = /* @__PURE__ */ new Map();
+  const needsResolution = unresolvedTokens.filter(
+    (t) => t.value.includes("#{") || t.value.includes("$")
+  );
+  if (needsResolution.length === 0) {
+    return resolvedMap;
+  }
+  try {
+    const sass = await import("./sass.node-4XJK6YBF-2NJM7G64.js");
+    const variablesPath = findVariablesFile(tokensDir);
+    if (!variablesPath) {
+      return resolvedMap;
+    }
+    const fileName = basename(variablesPath);
+    const moduleName = fileName.replace(/^_/, "").replace(/\.scss$/, "");
+    const scssSource = `
+@use '${moduleName}' as vars;
+:root { @include vars.fui-css-variables; }
+`;
+    const compiled = sass.compileString(scssSource, {
+      loadPaths: [tokensDir, dirname3(tokensDir)],
+      style: "expanded",
+      // Suppress sass deprecation warnings during build
+      logger: { warn() {
+      }, debug() {
+      } }
+    });
+    const cssVarRegex = /(--[\w-]+)\s*:\s*([^;]+)/g;
+    let match;
+    const allResolved = /* @__PURE__ */ new Map();
+    while ((match = cssVarRegex.exec(compiled.css)) !== null) {
+      allResolved.set(match[1], roundRgbValues(match[2].trim()));
+    }
+    for (const token of needsResolution) {
+      const value = allResolved.get(token.name);
+      if (value !== void 0) {
+        resolvedMap.set(token.name, value);
+      }
+    }
+  } catch {
+  }
+  return resolvedMap;
+}
+function findVariablesFile(tokensDir) {
+  const candidates = ["_variables.scss", "variables.scss"];
+  for (const name of candidates) {
+    const path = resolve3(tokensDir, name);
+    if (existsSync3(path)) {
+      return path;
+    }
+  }
+  try {
+    const files = readdirSync2(tokensDir).filter((f) => f.endsWith(".scss"));
+    for (const file of files) {
+      const path = resolve3(tokensDir, file);
+      if (file.includes("variables") || file.includes("tokens")) {
+        return path;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+export {
+  createComponentExtractor,
+  extractCustomPropsFromComponentFile,
+  resolveComponentSourcePath,
+  resolveTokensWithSass
+};
+//# sourceMappingURL=dist-V7D67NXS.js.map