sinwan-compiler 0.2.2 → 0.2.4

package/dist/{chunk-3bqqn28f.js → chunk-w580fdrf.js}

@@ -4,8 +4,8 @@ import * as path3 from "path";
 
 // src/analyze.ts
 import { parse } from "@babel/parser";
-import * as t2 from "@babel/types";
-import _traverse2 from "@babel/traverse";
+import * as t3 from "@babel/types";
+import _traverse3 from "@babel/traverse";
 import * as fs from "fs";
 import * as path2 from "path";
 
@@ -17,7 +17,8 @@ var traverse = typeof _traverse === "function" ? _traverse : _traverse.default ?
 var REACTIVE_SOURCE_MODULES = {
   "sinwan/store": new Set(["createMutable", "createStore"]),
   "sinwan/reactivity": new Set(["signal", "computed"]),
-  "sinwan/react": new Set(["useState"])
+  "sinwan/react": new Set(["useState"]),
+  "sinwan/hook": new Set(["useFetch"])
 };
 var COMPONENT_FACTORY_MODULES = {
   sinwan: new Set(["cc"]),
@@ -42,6 +43,9 @@ function isBuiltinReactiveProp(componentName, attrName) {
     return false;
   return entry.reactiveProps.has(attrName);
 }
+function isBuiltinControlFlowComponent(componentName) {
+  return !!componentName && BUILTIN_REACTIVE_PROPS.has(componentName);
+}
 function trackReactiveImports(ast) {
   const names = {
     createMutable: new Set,
@@ -49,6 +53,7 @@ function trackReactiveImports(ast) {
     signal: new Set,
     computed: new Set,
     useState: new Set,
+    useFetch: new Set,
     cc: new Set
   };
   traverse(ast, {
@@ -96,6 +101,32 @@ function isReactiveSourceCall(expr, names) {
   }
   return null;
 }
+var USEFETCH_CHAIN_METHODS = new Set([
+  "json",
+  "text",
+  "blob",
+  "arrayBuffer",
+  "formData",
+  "get",
+  "put",
+  "post",
+  "delete",
+  "patch",
+  "head",
+  "options"
+]);
+function isUseFetchCall(expr, names) {
+  if (!t.isCallExpression(expr))
+    return false;
+  const callee = expr.callee;
+  if (t.isIdentifier(callee)) {
+    return names.useFetch.has(callee.name);
+  }
+  if (t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property) && USEFETCH_CHAIN_METHODS.has(callee.property.name)) {
+    return isUseFetchCall(callee.object, names);
+  }
+  return false;
+}
 function trackLocalScopeBindings(path2, names, scope) {
   path2.traverse({
     VariableDeclarator(p) {
@@ -104,27 +135,42 @@ function trackLocalScopeBindings(path2, names, scope) {
       if (!init)
         return;
       const source = isReactiveSourceCall(init, names);
-      if (!source)
-        return;
-      if (source.isArray) {
-        if (t.isArrayPattern(id) && id.elements[0]) {
-          const first = id.elements[0];
-          if (t.isIdentifier(first)) {
-            scope.bindings.set(first.name, { kind: source.kind });
+      if (source) {
+        if (source.isArray) {
+          if (t.isArrayPattern(id) && id.elements[0]) {
+            const first = id.elements[0];
+            if (t.isIdentifier(first)) {
+              scope.bindings.set(first.name, { kind: source.kind });
+            }
+          }
+          return;
+        }
+        if (t.isIdentifier(id)) {
+          if (source.kind === "mutable") {
+            scope.bindings.set(id.name, {
+              kind: "mutable",
+              root: id.name,
+              path: []
+            });
+          } else {
+            scope.bindings.set(id.name, { kind: source.kind });
           }
         }
         return;
       }
-      if (t.isIdentifier(id)) {
-        if (source.kind === "mutable") {
-          scope.bindings.set(id.name, {
-            kind: "mutable",
-            root: id.name,
-            path: []
-          });
-        } else {
-          scope.bindings.set(id.name, { kind: source.kind });
+      if (isUseFetchCall(init, names)) {
+        if (t.isObjectPattern(id)) {
+          for (const prop of id.properties) {
+            if (t.isObjectProperty(prop) && !prop.computed && t.isIdentifier(prop.value)) {
+              scope.bindings.set(prop.value.name, {
+                kind: "signal"
+              });
+            }
+          }
+        } else if (t.isIdentifier(id)) {
+          scope.bindings.set(id.name, { kind: "signalObject" });
         }
+        return;
       }
     }
   });
@@ -241,16 +287,27 @@ function analyzeObjectLiteralSpread(spread, fullScope, calleeReactive) {
     }
   }
 }
+function isMemberLike(node) {
+  return t.isMemberExpression(node) || t.isOptionalMemberExpression(node);
+}
 function getMemberExpressionRootAndPath(node) {
   const path2 = [];
   let current = node;
-  while (t.isMemberExpression(current)) {
-    if (current.computed)
-      return null;
-    if (!t.isIdentifier(current.property))
-      return null;
-    path2.push(current.property.name);
-    current = current.object;
+  while (true) {
+    if (t.isTSNonNullExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (isMemberLike(current)) {
+      if (current.computed)
+        return null;
+      if (!t.isIdentifier(current.property))
+        return null;
+      path2.push(current.property.name);
+      current = current.object;
+      continue;
+    }
+    break;
   }
   if (t.isIdentifier(current)) {
     return { root: current.name, path: path2.reverse() };
@@ -258,6 +315,9 @@ function getMemberExpressionRootAndPath(node) {
   return null;
 }
 function isReactiveRead(node, scope) {
+  if (t.isTSNonNullExpression(node)) {
+    return isReactiveRead(node.expression, scope);
+  }
   if (t.isIdentifier(node)) {
     const binding2 = scope.bindings.get(node.name);
     if (!binding2)
@@ -270,6 +330,8 @@ function isReactiveRead(node, scope) {
     }
     return false;
   }
+  if (!isMemberLike(node))
+    return false;
   const rootPath = getMemberExpressionRootAndPath(node);
   if (!rootPath)
     return false;
@@ -285,6 +347,9 @@ function isReactiveRead(node, scope) {
   if (binding.kind === "signal" || binding.kind === "computed") {
     return rootPath.path[0] === "value";
   }
+  if (binding.kind === "signalObject") {
+    return rootPath.path.length >= 2 && rootPath.path[1] === "value";
+  }
   return false;
 }
 function isGetterCall(node, scope) {
@@ -295,12 +360,17 @@ function isGetterCall(node, scope) {
   return binding?.kind === "getter";
 }
 function isReactiveValue(node, scope) {
+  if (t.isTSNonNullExpression(node)) {
+    return isReactiveValue(node.expression, scope);
+  }
   if (t.isIdentifier(node)) {
     const binding2 = scope.bindings.get(node.name);
     if (!binding2)
       return false;
     return binding2.kind === "prop" || binding2.kind === "signal" || binding2.kind === "computed" || binding2.kind === "mutable";
   }
+  if (!isMemberLike(node))
+    return false;
   const rootPath = getMemberExpressionRootAndPath(node);
   if (!rootPath)
     return false;
@@ -313,6 +383,9 @@ function isReactiveValue(node, scope) {
   if (binding.kind === "signal" || binding.kind === "computed") {
     return rootPath.path[0] === "value";
   }
+  if (binding.kind === "signalObject") {
+    return rootPath.path.length >= 2 && rootPath.path[1] === "value";
+  }
   return false;
 }
 function containsReactiveValue(expr, scope) {
@@ -322,7 +395,7 @@ function containsReactiveValue(expr, scope) {
       return;
     if (!node || typeof node !== "object")
       return;
-    if (t.isMemberExpression(node) || t.isIdentifier(node)) {
+    if (isMemberLike(node) || t.isTSNonNullExpression(node) || t.isIdentifier(node)) {
       if (isReactiveValue(node, scope)) {
         found = true;
         return;
@@ -359,7 +432,7 @@ function containsReactiveRead(expr, scope) {
       return;
     if (!node || typeof node !== "object")
       return;
-    if (t.isMemberExpression(node) || t.isIdentifier(node)) {
+    if (isMemberLike(node) || t.isTSNonNullExpression(node) || t.isIdentifier(node)) {
       if (isReactiveRead(node, scope)) {
         found = true;
         return;
@@ -430,7 +503,7 @@ function getComponentExpressionInfo(exprPath) {
   }
   return { isComponent: true, componentName, attributeName };
 }
-function isReactiveComponentProp(info, componentNames, reactiveProps) {
+function isReactiveComponentProp(info, componentNames, reactiveProps, importedReactiveProps) {
   if (!info.isComponent || !info.componentName || !info.attributeName) {
     return false;
   }
@@ -438,12 +511,16 @@ function isReactiveComponentProp(info, componentNames, reactiveProps) {
     return true;
   }
   const componentFn = componentNames.get(info.componentName);
-  if (!componentFn)
-    return false;
-  const props = reactiveProps.get(componentFn);
-  if (!props)
+  if (componentFn) {
+    const props = reactiveProps.get(componentFn);
+    if (!props)
+      return false;
+    return props.has(info.attributeName);
+  }
+  const importedProps = importedReactiveProps.get(info.componentName);
+  if (!importedProps)
     return false;
-  return props.has(info.attributeName);
+  return importedProps.has(info.attributeName);
 }
 function shouldWrap(expr, scope) {
   if (t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr))
@@ -452,6 +529,65 @@ function shouldWrap(expr, scope) {
     return false;
   return containsReactiveRead(expr, scope);
 }
+var RESOLVE_HELPER = "_$unwrap";
+function transformPropMemberAccess(expr, scope) {
+  let changed = false;
+  function resolveRoot(rootName) {
+    return t.callExpression(t.identifier(RESOLVE_HELPER), [
+      t.identifier(rootName)
+    ]);
+  }
+  function replaceMemberRoot(node, rootName) {
+    let current = node;
+    let parent = null;
+    while (true) {
+      if (t.isTSNonNullExpression(current)) {
+        current = current.expression;
+        continue;
+      }
+      if (!isMemberLike(current))
+        break;
+      parent = current;
+      current = current.object;
+    }
+    if (parent && t.isIdentifier(current) && current.name === rootName) {
+      parent.object = resolveRoot(rootName);
+    }
+  }
+  function visit(node) {
+    if (!node || typeof node !== "object")
+      return;
+    if (t.isArrowFunctionExpression(node) || t.isFunctionExpression(node))
+      return;
+    if (isMemberLike(node)) {
+      const rootPath = getMemberExpressionRootAndPath(node);
+      if (rootPath) {
+        const binding = scope.bindings.get(rootPath.root);
+        if (binding && binding.kind === "prop") {
+          replaceMemberRoot(node, rootPath.root);
+          changed = true;
+          return;
+        }
+      }
+      return;
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments")
+        continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === "object")
+            visit(item);
+        }
+      } else if (value && typeof value === "object") {
+        visit(value);
+      }
+    }
+  }
+  visit(expr);
+  return changed;
+}
 function wrapExpression(expr) {
   return t.arrowFunctionExpression([], expr);
 }
@@ -681,53 +817,219 @@ function propagateReactiveProps(localScopes, callGraph, componentFunctions) {
   return reactiveProps;
 }
 function wrapReactiveExpressions(ast, options = {}) {
-  const names = trackReactiveImports(ast);
-  const hasAnyImport = Object.values(names).some((s) => s.size > 0);
-  if (!hasAnyImport)
-    return;
-  const {
-    functions: componentFunctions,
-    names: componentNames,
-    exported
-  } = collectComponentFunctions(ast, names.cc);
-  const localScopes = computeLocalScopes(ast, names);
-  const callGraph = collectComponentCallGraph(ast, componentNames);
-  const reactiveProps = propagateReactiveProps(localScopes, callGraph, componentFunctions);
-  const exportNameByFn = new Map;
-  for (const [localName, fn] of componentNames) {
-    if (exported.has(fn)) {
-      exportNameByFn.set(fn, localName);
+  let metadata = null;
+  if (options.analyzeMetadata) {
+    metadata = options.analyzeMetadata;
+  } else if (options.analyze && options.filename) {
+    try {
+      metadata = loadMetadata(options.analyze);
+    } catch {
+      metadata = null;
     }
   }
+  const absoluteFilename = options.filename ? path.resolve(options.filename) : null;
+  const resolveImport = options.resolveImport;
+  const names = {
+    createMutable: new Set,
+    createStore: new Set,
+    signal: new Set,
+    computed: new Set,
+    useState: new Set,
+    useFetch: new Set,
+    cc: new Set
+  };
+  const componentFunctions = new Set;
+  const componentNames = new Map;
+  const exported = new Set;
+  const localScopes = new Map;
+  const callGraph = new Map;
+  const rawCallGraph = new Map;
+  const importedReactiveProps = new Map;
+  const exportNameByFn = new Map;
+  let hasUnwrapImport = false;
   traverse(ast, {
-    ExportDefaultDeclaration(path2) {
-      const decl = path2.node.declaration;
+    ImportDeclaration(p) {
+      const source = p.node.source.value;
+      const reactiveAllowed = REACTIVE_SOURCE_MODULES[source];
+      const componentAllowed = COMPONENT_FACTORY_MODULES[source];
+      if (reactiveAllowed || componentAllowed) {
+        for (const spec of p.node.specifiers) {
+          if (!t.isImportSpecifier(spec))
+            continue;
+          const imported = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          if (reactiveAllowed?.has(imported)) {
+            names[imported].add(spec.local.name);
+          } else if (componentAllowed?.has(imported)) {
+            names.cc.add(spec.local.name);
+          }
+        }
+      }
+      if (source === "sinwan/reactivity") {
+        for (const spec of p.node.specifiers) {
+          if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported) && spec.imported.name === "unwrap") {
+            hasUnwrapImport = true;
+          }
+        }
+      }
+      if (metadata && absoluteFilename && resolveImport && source.startsWith(".")) {
+        const resolved = resolveImport(source, absoluteFilename);
+        if (resolved) {
+          const fileProps = metadata.get(resolved);
+          if (fileProps) {
+            for (const spec of p.node.specifiers) {
+              if (!t.isImportSpecifier(spec))
+                continue;
+              const imported = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+              if (!imported || !/^[A-Z]/.test(imported))
+                continue;
+              const props = fileProps.get(imported);
+              if (props && props.size > 0) {
+                importedReactiveProps.set(spec.local.name, new Set(props));
+              }
+            }
+          }
+        }
+      }
+    },
+    CallExpression(p) {
+      const callee = p.node.callee;
+      if (!t.isIdentifier(callee) || !names.cc.has(callee.name))
+        return;
+      const firstArg = p.node.arguments[0];
+      if (!firstArg || !t.isFunction(firstArg))
+        return;
+      const componentFn = firstArg;
+      componentFunctions.add(componentFn);
+      const parent = p.parentPath;
+      if (parent && parent.isVariableDeclarator && parent.isVariableDeclarator()) {
+        const id = parent.node.id;
+        if (t.isIdentifier(id)) {
+          componentNames.set(id.name, componentFn);
+        }
+      } else if (parent && parent.isExportNamedDeclaration && parent.isExportNamedDeclaration()) {
+        const declaration = parent.node.declaration;
+        if (t.isVariableDeclaration(declaration)) {
+          for (const decl of declaration.declarations) {
+            if (t.isIdentifier(decl.id)) {
+              componentNames.set(decl.id.name, componentFn);
+            }
+          }
+        }
+      }
+    },
+    ExportNamedDeclaration(p) {
+      const declaration = p.node.declaration;
+      if (!t.isVariableDeclaration(declaration))
+        return;
+      for (const decl of declaration.declarations) {
+        const init = decl.init;
+        if (!init || !t.isCallExpression(init))
+          continue;
+        const callee = init.callee;
+        if (!t.isIdentifier(callee) || !names.cc.has(callee.name))
+          continue;
+        const firstArg = init.arguments[0];
+        if (!firstArg || !t.isFunction(firstArg))
+          continue;
+        exported.add(firstArg);
+      }
+    },
+    ExportDefaultDeclaration(p) {
+      const decl = p.node.declaration;
       if (t.isIdentifier(decl)) {
         const fn = componentNames.get(decl.name);
-        if (fn)
+        if (fn) {
+          exported.add(fn);
           exportNameByFn.set(fn, "default");
+        }
       } else if (t.isCallExpression(decl)) {
         const callee = decl.callee;
         if (t.isIdentifier(callee) && names.cc.has(callee.name)) {
           const firstArg = decl.arguments[0];
           if (firstArg && t.isFunction(firstArg)) {
+            exported.add(firstArg);
             exportNameByFn.set(firstArg, "default");
           }
         }
       }
+    },
+    Function(p) {
+      const scope = { bindings: new Map };
+      trackLocalScopeBindings(p, names, scope);
+      localScopes.set(p.node, scope);
+    },
+    JSXElement(p) {
+      const name = p.node.openingElement.name;
+      if (!t.isJSXIdentifier(name))
+        return;
+      const callerPath = p.findParent((pp) => pp.isFunction());
+      const callerFn = callerPath ? callerPath.node : null;
+      if (!callerFn)
+        return;
+      const props = [];
+      const spreads = [];
+      for (const attr of p.node.openingElement.attributes) {
+        if (t.isJSXSpreadAttribute(attr)) {
+          if (attr.argument) {
+            spreads.push(attr.argument);
+          }
+          continue;
+        }
+        if (t.isJSXAttribute(attr)) {
+          const attrName = attr.name.name;
+          if (!attrName)
+            continue;
+          if (t.isJSXExpressionContainer(attr.value)) {
+            const expr = attr.value.expression;
+            if (!expr || t.isJSXEmptyExpression(expr))
+              continue;
+            props.push({ name: attrName, value: expr });
+          }
+        }
+      }
+      const childExprs = [];
+      for (const child of p.node.children) {
+        if (t.isJSXExpressionContainer(child)) {
+          const expr = child.expression;
+          if (!expr || t.isJSXEmptyExpression(expr))
+            continue;
+          childExprs.push(expr);
+        }
+      }
+      if (childExprs.length === 1) {
+        props.push({ name: "children", value: childExprs[0] });
+      } else if (childExprs.length > 1) {
+        props.push({ name: "children", value: t.arrayExpression(childExprs) });
+      }
+      const sites = rawCallGraph.get(callerFn) ?? [];
+      sites.push({ calleeName: name.name, props, spreads });
+      rawCallGraph.set(callerFn, sites);
     }
   });
-  let metadata = null;
-  if (options.analyzeMetadata) {
-    metadata = options.analyzeMetadata;
-  } else if (options.analyze && options.filename) {
-    try {
-      metadata = loadMetadata(options.analyze);
-    } catch {
-      metadata = null;
+  for (const [callerFn, sites] of rawCallGraph) {
+    const resolved = [];
+    for (const site of sites) {
+      const callee = componentNames.get(site.calleeName);
+      if (callee) {
+        resolved.push({ callee, props: site.props, spreads: site.spreads });
+      }
+    }
+    if (resolved.length > 0) {
+      callGraph.set(callerFn, resolved);
     }
   }
-  const absoluteFilename = options.filename ? path.resolve(options.filename) : null;
+  for (const [localName, fn] of componentNames) {
+    if (exported.has(fn)) {
+      if (!exportNameByFn.has(fn)) {
+        exportNameByFn.set(fn, localName);
+      }
+    }
+  }
+  const hasAnyImport = Object.values(names).some((s) => s.size > 0);
+  if (!hasAnyImport)
+    return;
+  const reactiveProps = propagateReactiveProps(localScopes, callGraph, componentFunctions);
+  let needsResolve = false;
   traverse(ast, {
     Function(path2) {
       const scope = localScopes.get(path2.node);
@@ -766,21 +1068,232 @@ function wrapReactiveExpressions(ast, options = {}) {
           const expr = exprPath.node.expression;
           const compInfo = getComponentExpressionInfo(exprPath);
           if (compInfo.isComponent) {
-            if (!isReactiveComponentProp(compInfo, componentNames, reactiveProps)) {
-              return;
+            if (compInfo.attributeName !== null) {
+              if (!isReactiveComponentProp(compInfo, componentNames, reactiveProps, importedReactiveProps)) {
+                return;
+              }
+            } else {
+              if (!isBuiltinControlFlowComponent(compInfo.componentName)) {
+                return;
+              }
             }
           }
           if (shouldWrap(expr, scope)) {
+            if (transformPropMemberAccess(expr, scope)) {
+              needsResolve = true;
+            }
             exprPath.replaceWith(t.jsxExpressionContainer(createBindingDescriptor(expr, exprPath, options)));
           }
         }
       });
     }
   });
+  if (needsResolve && !hasUnwrapImport) {
+    ast.program.body.unshift(t.importDeclaration([
+      t.importSpecifier(t.identifier(RESOLVE_HELPER), t.identifier("unwrap"))
+    ], t.stringLiteral("sinwan/reactivity")));
+  }
 }
 
-// src/analyze.ts
+// src/auto-cc.ts
+import * as t2 from "@babel/types";
+import _traverse2 from "@babel/traverse";
 var traverse2 = typeof _traverse2 === "function" ? _traverse2 : _traverse2.default ?? _traverse2;
+var CC_SOURCE_MODULES = new Set(["sinwan", "sinwan/component"]);
+var EXCLUDE_KEYS = new Set([
+  "loc",
+  "start",
+  "end",
+  "type",
+  "leadingComments",
+  "trailingComments",
+  "innerComments",
+  "extra"
+]);
+function isComponentName(name) {
+  return !!name && /^[A-Z]/.test(name);
+}
+function containsJsx(node, enterFunctions) {
+  if (!node || typeof node !== "object")
+    return false;
+  if (t2.isJSXElement(node) || t2.isJSXFragment(node))
+    return true;
+  if (!enterFunctions && (t2.isFunctionExpression(node) || t2.isArrowFunctionExpression(node) || t2.isFunctionDeclaration(node))) {
+    return false;
+  }
+  for (const key of Object.keys(node)) {
+    if (EXCLUDE_KEYS.has(key))
+      continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      for (const item of val) {
+        if (item && typeof item === "object" && containsJsx(item, enterFunctions)) {
+          return true;
+        }
+      }
+    } else if (val && typeof val === "object" && containsJsx(val, enterFunctions)) {
+      return true;
+    }
+  }
+  return false;
+}
+function functionReturnsJsx(fnPath) {
+  const fn = fnPath.node;
+  if (t2.isArrowFunctionExpression(fn) && !t2.isBlockStatement(fn.body)) {
+    return containsJsx(fn.body, false);
+  }
+  let found = false;
+  fnPath.traverse({
+    ReturnStatement(p) {
+      if (p.node.argument && containsJsx(p.node.argument, false)) {
+        found = true;
+        p.stop();
+      }
+    },
+    Function(p) {
+      p.skip();
+    }
+  });
+  return found;
+}
+function isComponentArity(fn) {
+  if (t2.isFunctionDeclaration(fn) && fn.generator)
+    return false;
+  if ((t2.isFunctionExpression(fn) || t2.isArrowFunctionExpression(fn)) && fn.generator) {
+    return false;
+  }
+  return fn.params.length <= 1;
+}
+function collectCcAliases(ast) {
+  const aliases = new Set;
+  traverse2(ast, {
+    ImportDeclaration(path2) {
+      const source = path2.node.source.value;
+      if (!CC_SOURCE_MODULES.has(source))
+        return;
+      for (const spec of path2.node.specifiers) {
+        if (!t2.isImportSpecifier(spec))
+          continue;
+        const imported = t2.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+        if (imported === "cc") {
+          aliases.add(spec.local.name);
+        }
+      }
+    }
+  });
+  return { aliases, alreadyImported: aliases.size > 0 };
+}
+function ccCall(arg, ccName) {
+  return t2.callExpression(t2.identifier(ccName), [arg]);
+}
+function autoWrapComponents(ast, filename) {
+  const { aliases, alreadyImported } = collectCcAliases(ast);
+  const ccName = aliases.values().next().value;
+  let changed = false;
+  const wrapIfCandidate = (fnPath, name) => {
+    if (name !== null && !isComponentName(name))
+      return "not-candidate";
+    const fn = fnPath.node;
+    if (!isComponentArity(fn))
+      return "not-candidate";
+    if (!functionReturnsJsx(fnPath))
+      return "not-candidate";
+    return "wrapped";
+  };
+  traverse2(ast, {
+    ExportNamedDeclaration(path2) {
+      const decl = path2.node.declaration;
+      if (!decl)
+        return;
+      if (t2.isFunctionDeclaration(decl) && decl.id) {
+        const name = decl.id.name;
+        if (!isComponentName(name))
+          return;
+        const fnPath = path2.get("declaration");
+        if (!isComponentArity(decl))
+          return;
+        if (!functionReturnsJsx(fnPath))
+          return;
+        const fnExpr = t2.functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async);
+        const varDecl = t2.variableDeclaration("const", [
+          t2.variableDeclarator(t2.identifier(name), ccCall(fnExpr, ccName ?? "cc"))
+        ]);
+        path2.replaceWith(t2.exportNamedDeclaration(varDecl, []));
+        changed = true;
+        return;
+      }
+      if (t2.isVariableDeclaration(decl)) {
+        for (const dPath of path2.get("declaration.declarations")) {
+          const id = dPath.node.id;
+          if (!t2.isIdentifier(id) || !isComponentName(id.name))
+            continue;
+          const init = dPath.node.init;
+          if (!init)
+            continue;
+          if (t2.isCallExpression(init) && t2.isIdentifier(init.callee) && aliases.has(init.callee.name)) {
+            continue;
+          }
+          if (!t2.isFunction(init))
+            continue;
+          const initPath = dPath.get("init");
+          if (!isComponentArity(init))
+            continue;
+          if (!functionReturnsJsx(initPath))
+            continue;
+          dPath.node.init = ccCall(init, ccName ?? "cc");
+          changed = true;
+        }
+        return;
+      }
+    },
+    ExportDefaultDeclaration(path2) {
+      const decl = path2.node.declaration;
+      if (t2.isFunctionDeclaration(decl) && decl.id) {
+        const name = decl.id.name;
+        if (!isComponentName(name))
+          return;
+        const fnPath = path2.get("declaration");
+        if (!isComponentArity(decl))
+          return;
+        if (!functionReturnsJsx(fnPath))
+          return;
+        const fnDecl = t2.functionDeclaration(decl.id, decl.params, decl.body, decl.generator, decl.async);
+        const exportDefault = t2.exportDefaultDeclaration(ccCall(t2.identifier(name), ccName ?? "cc"));
+        path2.replaceWithMultiple([fnDecl, exportDefault]);
+        changed = true;
+        return;
+      }
+      if (t2.isFunctionDeclaration(decl) && !decl.id) {
+        const fnPath = path2.get("declaration");
+        if (!isComponentArity(decl))
+          return;
+        if (!functionReturnsJsx(fnPath))
+          return;
+        const fnExpr = t2.functionExpression(null, decl.params, decl.body, decl.generator, decl.async);
+        path2.node.declaration = ccCall(fnExpr, ccName ?? "cc");
+        changed = true;
+        return;
+      }
+      if (t2.isArrowFunctionExpression(decl) || t2.isFunctionExpression(decl)) {
+        const declPath = path2.get("declaration");
+        if (!isComponentArity(decl))
+          return;
+        if (!functionReturnsJsx(declPath))
+          return;
+        path2.node.declaration = ccCall(decl, ccName ?? "cc");
+        changed = true;
+        return;
+      }
+    }
+  });
+  if (changed && !alreadyImported) {
+    ast.program.body.unshift(t2.importDeclaration([t2.importSpecifier(t2.identifier("cc"), t2.identifier("cc"))], t2.stringLiteral("sinwan/component")));
+  }
+  return changed;
+}
+
+// src/analyze.ts
+var traverse3 = typeof _traverse3 === "function" ? _traverse3 : _traverse3.default ?? _traverse3;
 function functionRef(fn) {
   return { start: fn.start ?? -1, end: fn.end ?? -1 };
 }
@@ -789,7 +1302,7 @@ function refKey(ref) {
 }
 function findFunctionByRef(ast, ref) {
   let found = null;
-  traverse2(ast, {
+  traverse3(ast, {
     Function(path3) {
       const node = path3.node;
       if (node.start === ref.start && node.end === ref.end) {
@@ -945,15 +1458,15 @@ function parseRefKey(key) {
 }
 function collectImports(ast) {
   const imports = new Map;
-  traverse2(ast, {
+  traverse3(ast, {
     ImportDeclaration(path3) {
       const source = path3.node.source.value;
       for (const spec of path3.node.specifiers) {
-        if (t2.isImportSpecifier(spec)) {
+        if (t3.isImportSpecifier(spec)) {
           const localName = spec.local.name;
-          const importedName = t2.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          const importedName = t3.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
           imports.set(localName, { source, importedName });
-        } else if (t2.isImportDefaultSpecifier(spec)) {
+        } else if (t3.isImportDefaultSpecifier(spec)) {
           imports.set(spec.local.name, { source, importedName: "default" });
         }
       }
@@ -963,10 +1476,10 @@ function collectImports(ast) {
 }
 function collectImportedCallSites(ast, componentNames, imports) {
   const sites = [];
-  traverse2(ast, {
+  traverse3(ast, {
     JSXElement(path3) {
       const name = path3.node.openingElement.name;
-      if (!t2.isJSXIdentifier(name))
+      if (!t3.isJSXIdentifier(name))
         return;
       const tagName = name.name;
       if (!/^[A-Z]/.test(tagName))
@@ -983,19 +1496,19 @@ function collectImportedCallSites(ast, componentNames, imports) {
       const props = [];
       const spreads = [];
       for (const attr of path3.node.openingElement.attributes) {
-        if (t2.isJSXSpreadAttribute(attr)) {
+        if (t3.isJSXSpreadAttribute(attr)) {
           if (attr.argument) {
             spreads.push(attr.argument);
           }
           continue;
         }
-        if (t2.isJSXAttribute(attr)) {
+        if (t3.isJSXAttribute(attr)) {
           const attrName = attr.name.name;
           if (!attrName)
             continue;
-          if (t2.isJSXExpressionContainer(attr.value)) {
+          if (t3.isJSXExpressionContainer(attr.value)) {
             const expr = attr.value.expression;
-            if (!expr || t2.isJSXEmptyExpression(expr))
+            if (!expr || t3.isJSXEmptyExpression(expr))
               continue;
             props.push({ name: attrName, value: expr });
           }
@@ -1003,9 +1516,9 @@ function collectImportedCallSites(ast, componentNames, imports) {
       }
       const childExprs = [];
       for (const child of path3.node.children) {
-        if (t2.isJSXExpressionContainer(child)) {
+        if (t3.isJSXExpressionContainer(child)) {
           const expr = child.expression;
-          if (!expr || t2.isJSXEmptyExpression(expr))
+          if (!expr || t3.isJSXEmptyExpression(expr))
             continue;
           childExprs.push(expr);
         }
@@ -1013,7 +1526,7 @@ function collectImportedCallSites(ast, componentNames, imports) {
       if (childExprs.length === 1) {
         props.push({ name: "children", value: childExprs[0] });
       } else if (childExprs.length > 1) {
-        props.push({ name: "children", value: t2.arrayExpression(childExprs) });
+        props.push({ name: "children", value: t3.arrayExpression(childExprs) });
       }
       sites.push({
         caller: callerFn,
@@ -1031,6 +1544,7 @@ function analyzeModule(code, filePath) {
     sourceType: "module",
     plugins: ["jsx", "typescript"]
   });
+  autoWrapComponents(ast, filePath);
   const names = trackReactiveImports(ast);
   const {
     functions,
@@ -1048,18 +1562,18 @@ function analyzeModule(code, filePath) {
       exports.set(localName, fn);
     }
   }
-  traverse2(ast, {
+  traverse3(ast, {
     ExportDefaultDeclaration(path3) {
       const decl = path3.node.declaration;
-      if (t2.isIdentifier(decl)) {
+      if (t3.isIdentifier(decl)) {
         const fn = componentNames.get(decl.name);
         if (fn)
           defaultExport = fn;
-      } else if (t2.isCallExpression(decl)) {
+      } else if (t3.isCallExpression(decl)) {
         const callee = decl.callee;
-        if (t2.isIdentifier(callee) && names.cc.has(callee.name)) {
+        if (t3.isIdentifier(callee) && names.cc.has(callee.name)) {
           const firstArg = decl.arguments[0];
-          if (firstArg && t2.isFunction(firstArg)) {
+          if (firstArg && t3.isFunction(firstArg)) {
             defaultExport = firstArg;
           }
         }
@@ -1845,4 +2359,4 @@ if (import.meta.main) {
   runAnalyzeCli();
 }
 
-export { analyzeModule, analyzeProject, AnalyzerCache, analyze, loadMetadata, trackReactiveImports, getAllPropNames, isReactiveValue, containsReactiveValue, collectComponentFunctions, computeLocalScopes, collectComponentCallGraph, buildFullScope, propagateReactiveProps, wrapReactiveExpressions, runAnalyzeCli };
+export { autoWrapComponents, analyzeModule, analyzeProject, AnalyzerCache, analyze, loadMetadata, trackReactiveImports, getAllPropNames, isReactiveValue, containsReactiveValue, collectComponentFunctions, computeLocalScopes, collectComponentCallGraph, buildFullScope, propagateReactiveProps, wrapReactiveExpressions, runAnalyzeCli };