@fragments-sdk/cli 0.9.0 → 0.10.0

package/dist/scan-generate-T5QNUG7N.js

@@ -0,0 +1,691 @@
+import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
+import "./chunk-566BNPQZ.js";
+import {
+  discoverAllComponents
+} from "./chunk-WXSR2II7.js";
+import {
+  extractPropsFromFile
+} from "./chunk-D5PYOXEI.js";
+import "./chunk-D2CDBRNU.js";
+import {
+  BRAND
+} from "./chunk-OQO55NKV.js";
+import "./chunk-Z7EY4VHE.js";
+
+// src/commands/scan-generate.ts
+import { readFile, writeFile, access, mkdir } from "fs/promises";
+import { resolve, basename, dirname, relative, join } from "path";
+import * as ts from "typescript";
+import pc from "picocolors";
+async function scanGenerate(options) {
+  const scanPath = resolve(options.scanPath);
+  const generated = [];
+  const skipped = [];
+  const errors = [];
+  console.log(pc.cyan(`
+${BRAND.name} Scan \u2192 Generate
+`));
+  console.log(pc.dim(`Scanning: ${scanPath}
+`));
+  console.log(pc.dim("Phase 1: Discovering components..."));
+  const defaultScanPatterns = [
+    "**/*.tsx",
+    "**/*.ts"
+  ];
+  const components = await discoverAllComponents(scanPath, {
+    patterns: options.patterns || defaultScanPatterns,
+    exclude: [
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/*.stories.*",
+      "**/*.fragment.*",
+      "**/*.d.ts",
+      "**/__tests__/**",
+      "**/__mocks__/**",
+      "**/node_modules/**",
+      "**/dist/**"
+    ]
+  });
+  if (components.length === 0) {
+    console.log(
+      pc.yellow("No components found. Check the path or file patterns.")
+    );
+    return {
+      success: false,
+      generated: [],
+      skipped: [],
+      errors: [{ name: "*", error: "No components found" }],
+      averageConfidence: 0
+    };
+  }
+  console.log(pc.green(`  Found ${components.length} components`));
+  console.log(pc.dim("\nPhase 2: Extracting component metadata..."));
+  const componentDataList = [];
+  for (const comp of components) {
+    let propsResult = null;
+    try {
+      propsResult = await extractPropsFromFile(comp.sourcePath, {
+        propsTypeName: `${comp.name}Props`
+      });
+    } catch {
+    }
+    let jsDoc = null;
+    try {
+      jsDoc = await extractComponentJSDoc(comp.sourcePath, comp.name);
+    } catch {
+    }
+    let compoundChildren = [];
+    try {
+      compoundChildren = await detectCompoundComponents(comp.sourcePath);
+    } catch {
+    }
+    let storyVariants = [];
+    if (!options.skipStorybook && comp.storyPath) {
+      try {
+        storyVariants = await extractStoryVariantsFromFile(comp.storyPath);
+      } catch {
+      }
+    }
+    componentDataList.push({
+      component: comp,
+      props: propsResult,
+      jsDoc,
+      compoundChildren,
+      storyVariants
+    });
+  }
+  const propsExtracted = componentDataList.filter(
+    (d) => d.props?.success && d.props.props.length > 0
+  ).length;
+  console.log(pc.green(`  Extracted props for ${propsExtracted} components`));
+  console.log(pc.dim("\nPhase 3: Generating fragment files..."));
+  for (const data of componentDataList) {
+    const comp = data.component;
+    const componentDir = dirname(comp.sourcePath);
+    const componentBaseName = basename(comp.sourcePath, ".tsx");
+    let fragmentDir;
+    if (options.outputDir) {
+      fragmentDir = resolve(options.outputDir, comp.name);
+      await mkdir(fragmentDir, { recursive: true });
+    } else {
+      fragmentDir = componentDir;
+    }
+    const fragmentPath = join(
+      fragmentDir,
+      `${componentBaseName}${BRAND.fileExtension}`
+    );
+    let fragmentExists = false;
+    try {
+      await access(fragmentPath);
+      fragmentExists = true;
+    } catch {
+    }
+    if (fragmentExists && !options.force) {
+      skipped.push({ name: comp.name, reason: "Fragment already exists" });
+      if (options.verbose) {
+        console.log(pc.dim(`  Skipping ${comp.name} (fragment exists)`));
+      }
+      continue;
+    }
+    try {
+      const confidence = calculateFieldConfidence(data);
+      const importPath = computeImportPath(
+        fragmentDir,
+        comp.sourcePath,
+        componentBaseName
+      );
+      const content = generateFragmentWithTodos(
+        comp.name,
+        importPath,
+        data,
+        confidence
+      );
+      await writeFile(fragmentPath, content, "utf-8");
+      const relPath = relative(process.cwd(), fragmentPath);
+      generated.push({
+        name: comp.name,
+        path: relPath,
+        confidence: confidence.score,
+        todoCount: confidence.todoFields.length
+      });
+      const confColor = confidence.score >= 70 ? pc.green : confidence.score >= 40 ? pc.yellow : pc.red;
+      console.log(
+        pc.green(`  \u2713 ${comp.name}`) + pc.dim(` (confidence: `) + confColor(`${confidence.score}`) + pc.dim(`, TODOs: ${confidence.todoFields.length})`)
+      );
+    } catch (e) {
+      errors.push({
+        name: comp.name,
+        error: e instanceof Error ? e.message : String(e)
+      });
+      console.log(pc.red(`  \u2717 ${comp.name}: ${e instanceof Error ? e.message : String(e)}`));
+    }
+  }
+  const avgConfidence = generated.length > 0 ? Math.round(
+    generated.reduce((sum, g) => sum + g.confidence, 0) / generated.length
+  ) : 0;
+  console.log(pc.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(pc.green(`
+\u2713 Generated ${generated.length} fragment file(s)`));
+  if (skipped.length > 0) {
+    console.log(
+      pc.dim(`  Skipped ${skipped.length} (use --force to overwrite)`)
+    );
+  }
+  if (errors.length > 0) {
+    console.log(pc.yellow(`  ${errors.length} error(s)`));
+  }
+  console.log(pc.dim(`  Average confidence: ${avgConfidence}/100`));
+  const totalTodos = generated.reduce((sum, g) => sum + g.todoCount, 0);
+  if (totalTodos > 0) {
+    console.log(
+      pc.dim(`  Total TODOs: ${totalTodos}`) + pc.dim(` \u2014 search for "TODO:" in generated files`)
+    );
+  }
+  console.log();
+  return {
+    success: errors.length === 0,
+    generated,
+    skipped,
+    errors,
+    averageConfidence: avgConfidence
+  };
+}
+async function extractComponentJSDoc(filePath, componentName) {
+  const content = await readFile(filePath, "utf-8");
+  return extractComponentJSDocFromSource(content, filePath, componentName);
+}
+function extractComponentJSDocFromSource(source, filePath, componentName) {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.ESNext,
+    true,
+    filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const targetName = componentName || basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
+  let componentDoc = null;
+  let propsInterfaceDoc = null;
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name?.text === targetName && hasExportModifier(statement)) {
+      const doc = getLeadingJSDoc(statement, sourceFile);
+      if (doc) componentDoc = doc;
+    }
+    if (ts.isVariableStatement(statement) && hasExportModifier(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name) && decl.name.text === targetName) {
+          const doc = getLeadingJSDoc(statement, sourceFile);
+          if (doc) componentDoc = doc;
+        }
+      }
+    }
+    if (ts.isFunctionDeclaration(statement) && hasDefaultExportModifier(statement)) {
+      const doc = getLeadingJSDoc(statement, sourceFile);
+      if (doc) componentDoc = doc;
+    }
+    if (ts.isInterfaceDeclaration(statement) && (statement.name.text === `${targetName}Props` || statement.name.text === `${targetName}Properties`)) {
+      const doc = getLeadingJSDoc(statement, sourceFile);
+      if (doc) propsInterfaceDoc = doc;
+    }
+  }
+  return componentDoc || propsInterfaceDoc;
+}
+function hasExportModifier(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function hasDefaultExportModifier(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  if (!modifiers) return false;
+  return modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) && modifiers.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+}
+function getLeadingJSDoc(node, sourceFile) {
+  const fullText = sourceFile.getFullText();
+  const nodeStart = node.getFullStart();
+  const nodePos = node.getStart(sourceFile);
+  const leadingText = fullText.slice(nodeStart, nodePos);
+  const jsDocMatch = leadingText.match(/\/\*\*([\s\S]*?)\*\//);
+  if (!jsDocMatch) return null;
+  const lines = jsDocMatch[1].split("\n");
+  const descriptionLines = [];
+  for (const line of lines) {
+    const trimmed = line.replace(/^\s*\*?\s?/, "").trim();
+    if (trimmed.startsWith("@")) break;
+    if (trimmed) descriptionLines.push(trimmed);
+  }
+  return descriptionLines.length > 0 ? descriptionLines.join(" ") : null;
+}
+async function detectCompoundComponents(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  return detectCompoundComponentsFromSource(content, filePath);
+}
+function detectCompoundComponentsFromSource(source, filePath) {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.ESNext,
+    true,
+    filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const subComponents = [];
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Object" && node.expression.name.text === "assign" && node.arguments.length >= 2) {
+      const secondArg = node.arguments[1];
+      if (ts.isObjectLiteralExpression(secondArg)) {
+        for (const prop of secondArg.properties) {
+          if (ts.isShorthandPropertyAssignment(prop)) {
+            subComponents.push(prop.name.text);
+          } else if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            subComponents.push(prop.name.text);
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  return subComponents;
+}
+async function extractStoryVariantsFromFile(storyPath) {
+  const content = await readFile(storyPath, "utf-8");
+  const variants = [];
+  const exportMatches = content.matchAll(
+    /export\s+const\s+([A-Z][a-zA-Z0-9]*)\s*[=:]/g
+  );
+  for (const match of exportMatches) {
+    const name = match[1];
+    if (name === "default" || name.endsWith("Args") || name.endsWith("Meta")) {
+      continue;
+    }
+    const args = extractStoryArgs(content, name);
+    variants.push({ name, args });
+  }
+  return variants;
+}
+function extractStoryArgs(content, storyName) {
+  const storyPattern = new RegExp(
+    `export\\s+const\\s+${storyName}[^=]*=\\s*\\{([\\s\\S]*?)\\n\\};`
+  );
+  const storyMatch = content.match(storyPattern);
+  if (!storyMatch) return {};
+  const storyBody = storyMatch[1];
+  const argsStart = storyBody.indexOf("args:");
+  if (argsStart === -1) return {};
+  const braceStart = storyBody.indexOf("{", argsStart);
+  if (braceStart === -1) return {};
+  let depth = 0;
+  let braceEnd = -1;
+  for (let i = braceStart; i < storyBody.length; i++) {
+    if (storyBody[i] === "{") depth++;
+    else if (storyBody[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        braceEnd = i;
+        break;
+      }
+    }
+  }
+  if (braceEnd === -1) return {};
+  const argsBlock = storyBody.slice(braceStart + 1, braceEnd).trim();
+  return parseArgsBlock(argsBlock);
+}
+function parseArgsBlock(argsBlock) {
+  const args = {};
+  const pairPattern = /(\w+)\s*:\s*(?:['"]([^'"]*?)['"]|(true|false)|(\d+(?:\.\d+)?))/g;
+  let pairMatch;
+  while ((pairMatch = pairPattern.exec(argsBlock)) !== null) {
+    const key = pairMatch[1];
+    if (pairMatch[2] !== void 0) {
+      args[key] = pairMatch[2];
+    } else if (pairMatch[3] !== void 0) {
+      args[key] = pairMatch[3] === "true";
+    } else if (pairMatch[4] !== void 0) {
+      args[key] = Number(pairMatch[4]);
+    }
+  }
+  return args;
+}
+function calculateFieldConfidence(data) {
+  let score = 0;
+  const todoFields = [];
+  const hasProps = data.props?.success && data.props.props.length > 0;
+  if (hasProps) {
+    score += 30;
+  }
+  if (data.jsDoc) {
+    score += 15;
+  } else {
+    todoFields.push("meta.description");
+  }
+  const category = inferCategory(
+    data.component.name,
+    data.props?.success ? data.props.props : []
+  );
+  if (category !== "Components") {
+    score += 10;
+  } else {
+    todoFields.push("meta.category");
+  }
+  if (data.storyVariants.length > 0) {
+    score += 25;
+  }
+  if (hasProps) {
+    const allResolved = data.props.props.every(
+      (p) => p.propType.type !== "custom"
+    );
+    if (allResolved) {
+      score += 10;
+    }
+  }
+  if (data.compoundChildren.length > 0) {
+    score += 5;
+  }
+  if (hasProps) {
+    const hasDefaults = data.props.props.some(
+      (p) => p.defaultValue !== void 0
+    );
+    if (hasDefaults) {
+      score += 5;
+    }
+  }
+  todoFields.push("usage.when");
+  todoFields.push("usage.whenNot");
+  return { score: Math.min(score, 100), todoFields };
+}
+var CATEGORY_PATTERNS = {
+  Actions: ["button", "action", "cta", "fab", "floatingaction"],
+  Forms: [
+    "form",
+    "input",
+    "select",
+    "checkbox",
+    "radio",
+    "textarea",
+    "field",
+    "textfield",
+    "datepicker",
+    "switch",
+    "slider",
+    "segmented"
+  ],
+  Layout: [
+    "layout",
+    "container",
+    "grid",
+    "flex",
+    "stack",
+    "box",
+    "divider",
+    "spacer",
+    "sidebar"
+  ],
+  Navigation: [
+    "nav",
+    "menu",
+    "breadcrumb",
+    "tab",
+    "link",
+    "pagination",
+    "stepper",
+    "topbar"
+  ],
+  Feedback: [
+    "alert",
+    "toast",
+    "notification",
+    "message",
+    "badge",
+    "indicator",
+    "progress",
+    "spinner",
+    "loading",
+    "loader",
+    "lozenge",
+    "chip"
+  ],
+  "Data Display": [
+    "table",
+    "list",
+    "card",
+    "avatar",
+    "stat",
+    "timeline",
+    "tree",
+    "datalist",
+    "datacard"
+  ],
+  Overlays: [
+    "modal",
+    "dialog",
+    "drawer",
+    "popover",
+    "tooltip",
+    "dropdown",
+    "slidepanel"
+  ],
+  Typography: ["text", "heading", "title", "label", "paragraph"],
+  Media: ["image", "video", "icon", "carousel"]
+};
+function inferCategory(componentName, props) {
+  const lower = componentName.toLowerCase();
+  for (const [category, patterns] of Object.entries(CATEGORY_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (lower.includes(pattern)) {
+        return category;
+      }
+    }
+  }
+  const propNames = new Set(props.map((p) => p.name));
+  if (propNames.has("onClick") || propNames.has("onPress")) return "Actions";
+  if (propNames.has("value") || propNames.has("defaultValue")) return "Forms";
+  if (propNames.has("children")) return "Layout";
+  return "Components";
+}
+function inferStatus(filePath) {
+  const lowerPath = filePath.toLowerCase();
+  if (lowerPath.includes("/experimental/") || lowerPath.includes("/labs/"))
+    return "experimental";
+  if (lowerPath.includes("/beta/")) return "beta";
+  if (lowerPath.includes("/deprecated/") || lowerPath.includes("/legacy/"))
+    return "deprecated";
+  if (lowerPath.includes("/draft/") || lowerPath.includes("/wip/"))
+    return "draft";
+  return "stable";
+}
+function inferDescription(componentName, props) {
+  const words = componentName.replace(/([A-Z])/g, " $1").trim().toLowerCase();
+  const propNames = new Set(props.map((p) => p.name));
+  const hasOnClick = propNames.has("onClick") || propNames.has("onPress");
+  const hasValue = propNames.has("value") || propNames.has("defaultValue");
+  const hasChildren = propNames.has("children");
+  if (hasOnClick && !hasValue)
+    return `Interactive ${words} element for triggering actions`;
+  if (hasValue) return `Form ${words} for user input`;
+  if (hasChildren) return `Container ${words} for grouping content`;
+  return `${words.charAt(0).toUpperCase() + words.slice(1)} component`;
+}
+function inferAccessibility(props) {
+  const propNames = new Set(props.map((p) => p.name));
+  const accessibility = {};
+  const hasOnClick = propNames.has("onClick") || propNames.has("onPress");
+  const hasAriaLabel = propNames.has("ariaLabel") || propNames.has("aria-label");
+  const hasDisabled = propNames.has("disabled");
+  const hasHref = propNames.has("href");
+  if (hasOnClick && !hasHref) accessibility.role = "button";
+  else if (hasHref) accessibility.role = "link";
+  const requirements = [];
+  if (hasOnClick && !hasAriaLabel)
+    requirements.push("Should have visible text or aria-label");
+  if (hasDisabled)
+    requirements.push(
+      "Disabled state should be conveyed to assistive technology"
+    );
+  if (requirements.length > 0) accessibility.requirements = requirements;
+  return accessibility;
+}
+function computeImportPath(fragmentDir, sourcePath, componentBaseName) {
+  const sourceDir = dirname(sourcePath);
+  if (fragmentDir === sourceDir) {
+    if (componentBaseName === "index") {
+      return ".";
+    }
+    return `./${componentBaseName}`;
+  }
+  let rel = relative(fragmentDir, sourceDir);
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  if (componentBaseName !== "index") {
+    rel = `${rel}/${componentBaseName}`;
+  }
+  return rel;
+}
+function escapeQuotes(str) {
+  return str.replace(/'/g, "\\'");
+}
+function generateFragmentWithTodos(componentName, importPath, data, confidence) {
+  const props = data.props?.success ? data.props.props : [];
+  const isDefaultExport = data.props?.success ? !data.props.propsTypeName : false;
+  const description = data.jsDoc || inferDescription(componentName, props);
+  const descriptionTodo = data.jsDoc ? "" : " // TODO: Review description";
+  const category = inferCategory(componentName, props);
+  const categoryTodo = category === "Components" ? " // TODO: Set correct category" : "";
+  const status = inferStatus(data.component.sourcePath);
+  const accessibility = inferAccessibility(props);
+  const propsBlock = buildPropsBlock(props);
+  const accessibilityBlock = buildAccessibilityBlock(accessibility);
+  const variantsBlock = buildVariantsBlock(
+    componentName,
+    data.storyVariants
+  );
+  const compoundComment = data.compoundChildren.length > 0 ? `
+  // Compound sub-components detected: ${data.compoundChildren.join(", ")}` : "";
+  return `// Auto-generated by fragments init --scan | Confidence: ${confidence.score}/100
+// ${confidence.todoFields.length} TODO(s) \u2014 search for "TODO:" and fill in human knowledge
+import React from 'react';
+import { defineFragment } from '@fragments-sdk/core';
+import { ${componentName} } from '${importPath}';
+
+export default defineFragment({
+  component: ${componentName},
+${compoundComment}
+  meta: {
+    name: '${escapeQuotes(componentName)}',
+    description: '${escapeQuotes(description)}',${descriptionTodo}
+    category: '${escapeQuotes(category)}',${categoryTodo}
+    status: '${status}',
+  },
+
+  usage: {
+    when: [
+      // TODO: Describe when to use ${componentName}
+    ],
+    whenNot: [
+      // TODO: Describe when NOT to use ${componentName}
+    ],
+  },
+
+  props: ${propsBlock},${accessibilityBlock}
+
+  variants: [
+${variantsBlock}
+  ],
+});
+`;
+}
+function buildPropsBlock(props) {
+  if (props.length === 0) return "{}";
+  const lines = props.map((prop) => {
+    const type = prop.propType.type;
+    const parts = [`      type: '${type}'`];
+    if (prop.description) {
+      parts.push(
+        `      description: '${escapeQuotes(prop.description.replace(/\n/g, " "))}'`
+      );
+    }
+    parts.push(`      required: ${prop.required}`);
+    if (prop.defaultValue !== void 0) {
+      parts.push(`      default: ${JSON.stringify(prop.defaultValue)}`);
+    }
+    if (prop.enumValues && prop.enumValues.length > 0) {
+      parts.push(`      values: ${JSON.stringify(prop.enumValues)}`);
+    }
+    const todoComment = type === "custom" ? " // TODO: Review type" : "";
+    return `    ${prop.name}: {
+${parts.join(",\n")},
+    },${todoComment}`;
+  });
+  return `{
+${lines.join("\n")}
+  }`;
+}
+function buildAccessibilityBlock(accessibility) {
+  if (!accessibility.role && (!accessibility.requirements || accessibility.requirements.length === 0)) {
+    return "";
+  }
+  const parts = [];
+  if (accessibility.role) {
+    parts.push(`    role: '${accessibility.role}'`);
+  }
+  if (accessibility.requirements && accessibility.requirements.length > 0) {
+    const reqs = accessibility.requirements.map((r) => `'${escapeQuotes(r)}'`).join(", ");
+    parts.push(`    requirements: [${reqs}]`);
+  }
+  return `
+
+  accessibility: {
+${parts.join(",\n")},
+  },`;
+}
+function buildVariantsBlock(componentName, storyVariants) {
+  const entries = [];
+  const hasDefault = storyVariants.some((v) => v.name === "Default");
+  if (!hasDefault) {
+    entries.push(formatVariantEntry(componentName, "Default", `Default ${componentName}`, {}));
+  }
+  for (const variant of storyVariants) {
+    const description = variant.name.replace(/([A-Z])/g, " $1").trim();
+    entries.push(
+      formatVariantEntry(
+        componentName,
+        variant.name,
+        `${description} ${componentName}`,
+        variant.args
+      )
+    );
+  }
+  return entries.join("\n");
+}
+function formatVariantEntry(componentName, name, description, args) {
+  const jsxCode = buildJsxString(componentName, args);
+  return `    {
+      name: '${escapeQuotes(name)}',
+      description: '${escapeQuotes(description)}',
+      code: \`${jsxCode}\`,
+      render: () => ${jsxCode},
+    },`;
+}
+function buildJsxString(componentName, args) {
+  const { children, ...restArgs } = args;
+  const propParts = [];
+  for (const [key, value] of Object.entries(restArgs)) {
+    if (typeof value === "string") {
+      propParts.push(`${key}="${escapeQuotes(value)}"`);
+    } else if (typeof value === "boolean") {
+      propParts.push(value ? key : `${key}={false}`);
+    } else if (typeof value === "number") {
+      propParts.push(`${key}={${value}}`);
+    }
+  }
+  const propsStr = propParts.length > 0 ? " " + propParts.join(" ") : "";
+  if (typeof children === "string") {
+    return `<${componentName}${propsStr}>${children}</${componentName}>`;
+  }
+  return `<${componentName}${propsStr} />`;
+}
+export {
+  calculateFieldConfidence,
+  detectCompoundComponents,
+  detectCompoundComponentsFromSource,
+  extractComponentJSDoc,
+  extractComponentJSDocFromSource,
+  scanGenerate
+};
+//# sourceMappingURL=scan-generate-T5QNUG7N.js.map