@fragments-sdk/cli 0.11.1 → 0.13.0

package/dist/{chunk-HRFUSSZI.js → chunk-3SOAPJDX.js}

@@ -2,7 +2,7 @@ import { createRequire as __banner_createRequire } from 'module'; const require
 import {
   BRAND,
   fragmentsConfigSchema
-} from "./chunk-OQO55NKV.js";
+} from "./chunk-QM7SVOGF.js";
 
 // src/core/config.ts
 import { existsSync } from "fs";
@@ -1409,4 +1409,4 @@ export {
   generateRegistry,
   generateContextMd
 };
-//# sourceMappingURL=chunk-HRFUSSZI.js.map
+//# sourceMappingURL=chunk-3SOAPJDX.js.map

package/dist/{chunk-D5PYOXEI.js → chunk-4K7EAQ5L.js}

@@ -2,7 +2,7 @@ import { createRequire as __banner_createRequire } from 'module'; const require
 import {
   BRAND,
   DEFAULTS
-} from "./chunk-OQO55NKV.js";
+} from "./chunk-QM7SVOGF.js";
 
 // src/service/browser-pool.ts
 import { chromium } from "playwright";
@@ -5937,7 +5937,7 @@ async function extractPropsFromFile(filePath, options = {}) {
 }
 function extractPropsFromSource(source, filePath, options = {}) {
   const { propsTypeName } = options;
-  const componentName = inferComponentName2(filePath);
+  const componentName = options.componentName || inferComponentName2(filePath);
   const result = {
     filePath,
     componentName,
@@ -5975,19 +5975,26 @@ function extractPropsFromSource(source, filePath, options = {}) {
       (d) => d.name.endsWith("Props") || d.name.endsWith("Properties")
     );
   }
-  if (!propsDecl) {
-    result.warnings.push(
-      `No props type found for ${componentName}. Looked for: ${targetName}`
-    );
+  if (propsDecl) {
+    result.propsTypeName = propsDecl.name;
+    if (ts.isInterfaceDeclaration(propsDecl.node)) {
+      extractPropsFromInterface2(propsDecl.node, sourceFile, result);
+    } else if (ts.isTypeAliasDeclaration(propsDecl.node)) {
+      extractPropsFromTypeAlias2(propsDecl.node, sourceFile, result);
+    }
+    result.success = result.props.length > 0;
     return result;
   }
-  result.propsTypeName = propsDecl.name;
-  if (ts.isInterfaceDeclaration(propsDecl.node)) {
-    extractPropsFromInterface2(propsDecl.node, sourceFile, result);
-  } else if (ts.isTypeAliasDeclaration(propsDecl.node)) {
-    extractPropsFromTypeAlias2(propsDecl.node, sourceFile, result);
+  const inlineProps = extractPropsFromInlineParams(componentName, sourceFile);
+  if (inlineProps.length > 0) {
+    result.props = inlineProps;
+    result.propsTypeName = `${componentName}(inline)`;
+    result.success = true;
+    return result;
   }
-  result.success = result.props.length > 0;
+  result.warnings.push(
+    `No props type found for ${componentName}. Looked for: ${targetName}`
+  );
   return result;
 }
 function extractPropsFromInterface2(node, sourceFile, result) {
@@ -6204,6 +6211,134 @@ function parseTypeNode(node, sourceFile) {
     propType: { type: "custom", typescript: node.getText(sourceFile) }
   };
 }
+function extractPropsFromInlineParams(componentName, sourceFile) {
+  const props = [];
+  const seen = /* @__PURE__ */ new Set();
+  let targetFunc;
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isFunctionDeclaration(node) && node.name?.text === componentName) {
+      targetFunc = node;
+    }
+    if (ts.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name) && decl.name.text === componentName && decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+          targetFunc = decl.initializer;
+        }
+      }
+    }
+  });
+  if (!targetFunc || targetFunc.parameters.length === 0) return props;
+  const firstParam = targetFunc.parameters[0];
+  if (ts.isObjectBindingPattern(firstParam.name)) {
+    for (const element of firstParam.name.elements) {
+      if (ts.isBindingElement(element) && ts.isIdentifier(element.name)) {
+        const name = element.name.text;
+        if (name === "props" || name === "rest" || name.startsWith("_")) continue;
+        if (name === "className" || name === "children" || name === "ref") continue;
+        if (seen.has(name)) continue;
+        seen.add(name);
+        const hasDefault = element.initializer !== void 0;
+        let defaultValue = void 0;
+        let enumValues;
+        let propType = { type: "string" };
+        if (element.initializer) {
+          if (ts.isStringLiteral(element.initializer)) {
+            defaultValue = element.initializer.text;
+          } else if (element.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+            defaultValue = true;
+            propType = { type: "boolean" };
+          } else if (element.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+            defaultValue = false;
+            propType = { type: "boolean" };
+          } else if (ts.isNumericLiteral(element.initializer)) {
+            defaultValue = Number(element.initializer.text);
+            propType = { type: "number" };
+          }
+        }
+        const prop = {
+          name,
+          type: propType.type,
+          propType,
+          description: "",
+          required: !hasDefault && !element.dotDotDotToken
+        };
+        if (defaultValue !== void 0) prop.defaultValue = defaultValue;
+        if (enumValues) prop.enumValues = enumValues;
+        props.push(prop);
+      }
+    }
+  }
+  if (firstParam.type) {
+    extractFromInlineType(firstParam.type, sourceFile, props, seen);
+  }
+  extractCvaVariants(sourceFile, props);
+  return props;
+}
+function extractFromInlineType(typeNode, sourceFile, props, seen) {
+  if (ts.isIntersectionTypeNode(typeNode)) {
+    for (const type of typeNode.types) {
+      extractFromInlineType(type, sourceFile, props, seen);
+    }
+  } else if (ts.isTypeLiteralNode(typeNode)) {
+    for (const member of typeNode.members) {
+      if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+        const name = member.name.text;
+        if (seen.has(name) || name === "className" || name === "children") continue;
+        seen.add(name);
+        const prop = extractPropFromSignature(member, sourceFile);
+        if (prop) props.push(prop);
+      }
+    }
+  }
+}
+function extractCvaVariants(sourceFile, props) {
+  const cvaVariants = /* @__PURE__ */ new Map();
+  function visitCva(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "cva" && node.arguments.length >= 2) {
+      const configArg = node.arguments[1];
+      if (ts.isObjectLiteralExpression(configArg)) {
+        for (const prop of configArg.properties) {
+          if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "variants" && ts.isObjectLiteralExpression(prop.initializer)) {
+            for (const variantProp of prop.initializer.properties) {
+              if (ts.isPropertyAssignment(variantProp) && ts.isIdentifier(variantProp.name) && ts.isObjectLiteralExpression(variantProp.initializer)) {
+                const variantName = variantProp.name.text;
+                const values = [];
+                for (const valueProp of variantProp.initializer.properties) {
+                  if (ts.isPropertyAssignment(valueProp)) {
+                    const key = valueProp.name;
+                    if (ts.isIdentifier(key)) {
+                      values.push(key.text);
+                    } else if (ts.isStringLiteral(key)) {
+                      values.push(key.text);
+                    } else if (ts.isComputedPropertyName(key)) {
+                      const expr = key.expression;
+                      if (ts.isStringLiteral(expr)) {
+                        values.push(expr.text);
+                      }
+                    }
+                  }
+                }
+                if (values.length > 0) {
+                  cvaVariants.set(variantName, values);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visitCva);
+  }
+  ts.forEachChild(sourceFile, visitCva);
+  for (const prop of props) {
+    const values = cvaVariants.get(prop.name);
+    if (values && values.length > 0) {
+      prop.enumValues = values;
+      prop.propType = { type: "enum", values };
+      prop.type = values.map((v) => `"${v}"`).join(" | ");
+    }
+  }
+}
 function inferComponentName2(filePath) {
   const fileName = basename4(filePath);
   let name = fileName.replace(/\.(tsx?|jsx?)$/, "");
@@ -6641,4 +6776,4 @@ export {
   getStorybookStoryIds,
   renderAllComponentVariants
 };
-//# sourceMappingURL=chunk-D5PYOXEI.js.map
+//# sourceMappingURL=chunk-4K7EAQ5L.js.map