@actview/plugin-babel 1.0.3

package/README.md

@@ -0,0 +1,64 @@
+# @actview/plugin-babel
+
+> **迁移记录**：本包原为 `@actview/babel-plugin-actview`（目录 `plugins/babel-plugin-actview`），现更名为 `@actview/plugin-babel`（目录 `plugins/babel`），与 `@actview/plugin-vite` / `@actview/plugin-scoped` 统一为 `@actview/plugin-*` 命名。旧包名已弃用，请使用新包名安装与引用。
+
+**ActView 编译核心（Babel 插件）** —— 把 JSX 组件函数自动转换为 `defineComponent`，独立于 Vite 宿主。
+
+Babel 插件 `defineComponentPlugin` 是 ActView 编译链的**核心**：将大写开头的函数 / 箭头 / 默认导出组件包装为 `defineComponent` 产物（`{ __setup }`），并完成具名插槽提取、props 白名单、早退 return 包装等转换。`@actview/plugin-vite` 与 `@actview/plugin-scoped` 都基于它。
+
+同时本包导出**共享 Babel 宿主壳**（`createBabelTransform` / `createBabelItem` / `transformWithBabel`），供各 Vite 插件复用统一的 `transformSync` 调用参数。
+
+## 核心功能
+
+- **组件自动转换**：函数 / 箭头 / 默认导出组件 → `defineComponent`（自动注入 `import { defineComponent } from '@actview/core'`）
+- **具名插槽**：`<template slot>` → `slots` prop（编译期提取）
+- **props 白名单**：从 `defineComponent({ props })` 声明提取 `__props`
+- **早退 return**：组件渲染函数中的 `if / 三元 / &&` 早退分支包装（`isRenderExpr`）
+- **共享宿主壳**：`createBabelTransform` 等，统一 `parserOpts` / `retainLines` / `sourceMaps` / `babelrc:false` / `configFile:false`
+
+## 安装
+
+```bash
+pnpm add -D @actview/plugin-babel
+```
+
+## 快速开始
+
+```ts
+import { defineComponentPlugin } from '@actview/plugin-babel'
+import * as babel from '@babel/core'
+
+const result = babel.transformSync(code, {
+  filename: 'App.tsx',
+  plugins: [[defineComponentPlugin, {}]],
+  parserOpts: { plugins: ['jsx', 'typescript'] },
+})
+```
+
+> 大多数场景不需要直接使用 —— 接入 `@actview/plugin-vite`（Vite 项目）即可自动完成转换。
+
+## API
+
+| 导出 | 说明 |
+|---|---|
+| `defineComponentPlugin`（默认导出同） | Babel 插件工厂：组件 → `defineComponent` 转换 |
+| `createBabelTransform(plugin)` | 宿主壳工厂：模块级创建一次 ConfigItem，返回 `(code, filename) => { code, map } \| null` |
+| `createBabelItem(plugin)` | 把插件工厂预编译为 ConfigItem（Babel 8 同步） |
+| `transformWithBabel(code, filename, pluginItem)` | 统一参数的 `transformSync` |
+| 类型：`BabelPlugin` / `BabelHostResult` | 宿主壳类型 |
+
+## 依赖关系
+
+- `@babel/core`（^8）
+- 被依赖方：`@actview/plugin-vite`、`@actview/plugin-scoped`（复用宿主壳）
+
+## 开发
+
+```bash
+pnpm build   # tsup 打包 dist
+pnpm test    # vitest（test/plugin.test.ts：组件转换/插槽/props/早退等 30 用例）
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { PluginObject, PluginItem } from '@babel/core';
+
+declare function defineComponentPlugin(): {
+    visitor: {
+        Program: {
+            enter(): void;
+            exit(path: any): void;
+        };
+        FunctionDeclaration(path: any): void;
+        VariableDeclarator(path: any): void;
+        JSXElement(path: any): void;
+        JSXFragment(path: any): void;
+        ExportDefaultDeclaration(path: any): void;
+    };
+};
+
+/** Babel 插件工厂形态（() => { visitor }），createConfigItemSync 的标准输入 */
+type BabelPlugin = () => PluginObject;
+/** transformSync 统一产物（result.map 类型为 BabelSourceMap | null | undefined） */
+interface BabelHostResult {
+    code: string;
+    map: unknown;
+}
+/** 把插件工厂预编译为 ConfigItem（Babel 8 同步版本，可跨多次 transformSync 复用） */
+declare function createBabelItem(plugin: BabelPlugin): PluginItem;
+/** 统一参数的 transformSync：失败返回 null，成功返回 { code, map } */
+declare function transformWithBabel(code: string, filename: string, pluginItem: PluginItem): BabelHostResult | null;
+/**
+ * 静态插件的便捷工厂：模块级调用一次，ConfigItem 只创建一次。
+ * 适用于插件对象不随文件变化的场景（如 defineComponentPlugin）。
+ */
+declare function createBabelTransform(plugin: BabelPlugin | BabelPlugin[]): (code: string, filename: string) => BabelHostResult | null;
+
+declare function solidPlugin(): {
+    visitor: {
+        Program: {
+            enter(): void;
+            exit(path: any): void;
+        };
+    };
+};
+
+export { type BabelHostResult, createBabelItem, createBabelTransform, defineComponentPlugin as default, defineComponentPlugin, solidPlugin, transformWithBabel };

package/dist/index.js

@@ -0,0 +1,709 @@
+// src/babel-plugin.ts
+import { types as t } from "@babel/core";
+import generate from "@babel/generator";
+function extractNamedSlots(el) {
+  const nameNode = el.openingElement.name;
+  if (!t.isJSXIdentifier(nameNode) || !/^[A-Z]/.test(nameNode.name)) return;
+  const children = el.children;
+  const slotProps = [];
+  const remaining = [];
+  for (const child of children) {
+    if (t.isJSXElement(child) && t.isJSXIdentifier(child.openingElement.name, { name: "template" })) {
+      const attrs = child.openingElement.attributes;
+      const slotAttr = attrs.find(
+        (a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name: "slot" })
+      );
+      if (slotAttr && t.isStringLiteral(slotAttr.value)) {
+        const scopeParams = attrs.filter(
+          (a) => t.isJSXAttribute(a) && !t.isJSXIdentifier(a.name, { name: "slot" }) && !a.value
+        ).map((a) => t.identifier(a.name.name));
+        const slotBody = t.jsxFragment(
+          t.jsxOpeningFragment(),
+          t.jsxClosingFragment(),
+          child.children
+        );
+        slotProps.push(
+          t.objectProperty(
+            t.stringLiteral(slotAttr.value.value),
+            t.arrowFunctionExpression(scopeParams, slotBody)
+          )
+        );
+        continue;
+      }
+    }
+    remaining.push(child);
+  }
+  if (!slotProps.length) return;
+  el.children = remaining;
+  el.openingElement.attributes.push(
+    t.jsxAttribute(
+      t.jsxIdentifier("slots"),
+      t.jsxExpressionContainer(t.objectExpression(slotProps))
+    )
+  );
+}
+function walkJSX(node) {
+  if (t.isJSXElement(node)) {
+    extractNamedSlots(node);
+    node.children.forEach(walkJSX);
+  } else if (t.isJSXFragment(node)) {
+    node.children.forEach(walkJSX);
+  } else if (t.isJSXExpressionContainer(node)) {
+    walkExpression(node.expression);
+  }
+}
+function walkExpression(expr) {
+  if (!expr) return;
+  if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
+    walkJSX(expr);
+  } else if (t.isJSXExpressionContainer(expr)) {
+    walkExpression(expr.expression);
+  } else if (t.isLogicalExpression(expr) || t.isBinaryExpression(expr)) {
+    walkExpression(expr.left);
+    walkExpression(expr.right);
+  } else if (t.isConditionalExpression(expr)) {
+    walkExpression(expr.consequent);
+    walkExpression(expr.alternate);
+  } else if (t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr)) {
+    walkExpression(expr.body);
+  } else if (t.isCallExpression(expr)) {
+    expr.arguments.forEach(walkExpression);
+  } else if (t.isArrayExpression(expr)) {
+    expr.elements.forEach(walkExpression);
+  } else if (t.isObjectExpression(expr)) {
+    expr.properties.forEach((p) => walkExpression(p.value));
+  }
+}
+function defineComponentPlugin() {
+  let hasTransformed = false;
+  const jstate = { usedJsx: false, usedFragment: false };
+  return {
+    visitor: {
+      Program: {
+        enter() {
+          hasTransformed = false;
+          jstate.usedJsx = false;
+          jstate.usedFragment = false;
+        },
+        exit(path) {
+          if (jstate.usedJsx) {
+            const jsxSpecs = [];
+            if (jstate.usedJsx) {
+              jsxSpecs.push(t.importSpecifier(t.identifier("_jsx"), t.identifier("jsx")));
+            }
+            if (jstate.usedFragment) {
+              jsxSpecs.push(
+                t.importSpecifier(t.identifier("_Fragment"), t.identifier("Fragment"))
+              );
+            }
+            const hasJsxImport = path.node.body.some(
+              (n) => t.isImportDeclaration(n) && n.source.value === "@actview/jsx/jsx-runtime"
+            );
+            if (!hasJsxImport) {
+              path.node.body.unshift(
+                t.importDeclaration(jsxSpecs, t.stringLiteral("@actview/jsx/jsx-runtime"))
+              );
+            }
+          }
+          if (!hasTransformed) return;
+          const alreadyImported = path.node.body.some(
+            (n) => t.isImportDeclaration(n) && n.specifiers.some(
+              (s) => s.imported?.name === "defineComponent"
+            )
+          );
+          if (!alreadyImported) {
+            path.node.body.unshift(
+              t.importDeclaration(
+                [t.importSpecifier(t.identifier("defineComponent"), t.identifier("defineComponent"))],
+                t.stringLiteral("@actview/core")
+              )
+            );
+          }
+        }
+      },
+      FunctionDeclaration(path) {
+        const node = path.node;
+        if (!node.id) return;
+        const name = node.id.name;
+        if (!/^[A-Z]/.test(name)) return;
+        const fn = t.functionExpression(null, node.params, node.body, false, false);
+        const wrapped = wrapComponentFn(fn, name);
+        if (!wrapped) return;
+        const call = wrapped;
+        hasTransformed = true;
+        wrapEarlyReturns(path);
+        path.replaceWith(
+          t.variableDeclaration("const", [
+            t.variableDeclarator(node.id, call)
+          ])
+        );
+      },
+      // 缺陷 2 修复：函数表达式 / 箭头函数组件
+      //   const X = function (props) {...}
+      //   const X = (props) => <JSX>  /  (props) => { ...; return function(){...} }
+      VariableDeclarator(path) {
+        const node = path.node;
+        const id = node.id;
+        if (!t.isIdentifier(id) || !/^[A-Z]/.test(id.name)) return;
+        const init = node.init;
+        const isFn = t.isFunctionExpression(init) || t.isArrowFunctionExpression(init);
+        if (!isFn) return;
+        const wrapped = wrapComponentFn(init, id.name);
+        if (!wrapped) return;
+        const call = wrapped;
+        hasTransformed = true;
+        const initPath = path.get("init");
+        wrapEarlyReturns(initPath);
+        node.init = call;
+      },
+      // 顺带支持：export default (props) => <JSX>（默认导出箭头/函数/匿名函数组件）
+      // JSX 编译：组件转换（含 <solid> 提取）之后剩余 JSX → _jsx 调用
+      JSXElement(path) {
+        const name = path.node.openingElement.name;
+        if (t.isJSXIdentifier(name) && name.name === "solid") {
+          path.replaceWith(buildSolidMark(path.node, jstate));
+          return;
+        }
+        path.replaceWith(compileJsxElement(path.node, jstate));
+      },
+      JSXFragment(path) {
+        path.replaceWith(compileJsxFragment(path.node, jstate));
+      },
+      ExportDefaultDeclaration(path) {
+        const decl = path.node.declaration;
+        const isFn = t.isFunctionExpression(decl) || t.isArrowFunctionExpression(decl) || // export default function() {...}（匿名函数声明）
+        t.isFunctionDeclaration(decl);
+        if (!isFn) return;
+        const fn = t.isFunctionDeclaration(decl) ? t.functionExpression(null, decl.params, decl.body, false, false) : decl;
+        const wrapped = wrapComponentFn(fn);
+        if (!wrapped) return;
+        const call = wrapped;
+        hasTransformed = true;
+        const declPath = path.get("declaration");
+        wrapEarlyReturns(declPath);
+        path.node.declaration = call;
+      }
+    }
+  };
+}
+function wrapComponentFn(fn, name) {
+  const body = fn.body;
+  const isExprBody = !t.isBlockStatement(body);
+  let last = null;
+  let ret;
+  if (isExprBody) {
+    ret = body;
+  } else {
+    const stmts = body.body;
+    if (stmts.length === 0) return null;
+    last = stmts[stmts.length - 1];
+    if (!t.isReturnStatement(last)) return null;
+    ret = last.argument;
+    if (ret == null) return null;
+  }
+  const isJsx = t.isJSXElement(ret) || t.isJSXFragment(ret);
+  const isJsxCall = t.isCallExpression(ret) && t.isIdentifier(ret.callee) && /^_?jsx/.test(ret.callee.name);
+  const isNullRet = t.isNullLiteral(ret);
+  const isCondRet = isRenderExpr(ret);
+  if (!isJsx && !isJsxCall && !isNullRet && !isCondRet) return null;
+  if (isJsx) walkJSX(ret);
+  if (isExprBody) {
+    fn.body = t.blockStatement([
+      t.returnStatement(t.arrowFunctionExpression([], ret))
+    ]);
+  } else if (isJsx || isJsxCall || isCondRet) {
+    last.argument = t.arrowFunctionExpression([], ret);
+  } else if (isNullRet) {
+    last.argument = t.arrowFunctionExpression([], t.nullLiteral());
+  }
+  const args = [fn];
+  if (name) args.push(t.stringLiteral(name));
+  return t.callExpression(t.identifier("defineComponent"), args);
+}
+function wrapEarlyReturns(fnPath) {
+  fnPath.traverse({
+    ReturnStatement(innerPath) {
+      if (innerPath.getFunctionParent() !== fnPath) return;
+      const arg = innerPath.node.argument;
+      if (arg == null) return;
+      const isStmtJsx = t.isJSXElement(arg) || t.isJSXFragment(arg);
+      const isStmtJsxCall = t.isCallExpression(arg) && t.isIdentifier(arg.callee) && /^_?jsx/.test(arg.callee.name);
+      const isStmtNull = t.isNullLiteral(arg);
+      const isStmtCond = isRenderExpr(arg);
+      if (isStmtJsx || isStmtJsxCall || isStmtNull || isStmtCond) {
+        innerPath.node.argument = t.arrowFunctionExpression([], arg);
+      }
+    }
+  });
+}
+function isRenderExpr(expr) {
+  if (!expr) return false;
+  if (t.isJSXElement(expr) || t.isJSXFragment(expr)) return true;
+  if (t.isCallExpression(expr) && t.isIdentifier(expr.callee) && /^_?jsx/.test(expr.callee.name)) {
+    return true;
+  }
+  if (t.isConditionalExpression(expr)) {
+    return isRenderExpr(expr.consequent) || isRenderExpr(expr.alternate);
+  }
+  if (t.isLogicalExpression(expr)) {
+    return isRenderExpr(expr.right) || isRenderExpr(expr.left);
+  }
+  return false;
+}
+function compileJsxElement(el, state) {
+  const name = el.openingElement.name;
+  let typeExpr;
+  if (t.isJSXIdentifier(name)) {
+    typeExpr = /^[a-z]/.test(name.name) ? t.stringLiteral(name.name) : t.identifier(name.name);
+  } else if (t.isJSXMemberExpression(name)) {
+    typeExpr = jsxMemberToMember(name);
+  } else {
+    typeExpr = t.stringLiteral(name.name);
+  }
+  let keyExpr = null;
+  const propEntries = [];
+  for (const attr of el.openingElement.attributes) {
+    if (t.isJSXSpreadAttribute(attr)) {
+      propEntries.push(t.spreadElement(attr.argument));
+      continue;
+    }
+    const aname = attr.name.name;
+    let value;
+    if (attr.value == null) {
+      value = t.booleanLiteral(true);
+    } else if (t.isStringLiteral(attr.value)) {
+      value = attr.value;
+    } else {
+      value = attr.value.expression;
+    }
+    if (aname === "key") {
+      keyExpr = t.isStringLiteral(value) ? value : value;
+      continue;
+    }
+    propEntries.push(t.objectProperty(t.stringLiteral(aname), value));
+  }
+  const children = compileJsxChildren(el.children, state);
+  if (children.length === 1) {
+    propEntries.push(t.objectProperty(t.stringLiteral("children"), children[0]));
+  } else if (children.length > 1) {
+    propEntries.push(
+      t.objectProperty(t.stringLiteral("children"), t.arrayExpression(children))
+    );
+  }
+  state.usedJsx = true;
+  const args = [typeExpr, t.objectExpression(propEntries)];
+  args.push(keyExpr ?? t.identifier("undefined"));
+  return t.callExpression(t.identifier("_jsx"), args);
+}
+function compileJsxFragment(frag, state) {
+  const children = compileJsxChildren(frag.children, state);
+  state.usedJsx = true;
+  state.usedFragment = true;
+  const propEntries = [];
+  if (children.length === 1) {
+    propEntries.push(t.objectProperty(t.stringLiteral("children"), children[0]));
+  } else if (children.length > 1) {
+    propEntries.push(
+      t.objectProperty(t.stringLiteral("children"), t.arrayExpression(children))
+    );
+  }
+  return t.callExpression(t.identifier("_jsx"), [
+    t.identifier("_Fragment"),
+    t.objectExpression(propEntries),
+    t.identifier("undefined")
+  ]);
+}
+function compileJsxChildren(children, state) {
+  const out = [];
+  for (const c of children) {
+    if (t.isJSXText(c)) {
+      if (c.value.trim() === "") continue;
+      out.push(t.stringLiteral(processJsxText(c.value)));
+    } else if (t.isJSXExpressionContainer(c)) {
+      if (t.isJSXEmptyExpression(c.expression)) continue;
+      out.push(c.expression);
+    } else if (t.isJSXElement(c)) {
+      const cname = c.openingElement.name;
+      if (t.isJSXIdentifier(cname) && cname.name === "solid") {
+        out.push(buildSolidMark(c, state));
+      } else {
+        out.push(compileJsxElement(c, state));
+      }
+    } else if (t.isJSXFragment(c)) {
+      out.push(compileJsxFragment(c, state));
+    }
+  }
+  return out;
+}
+function jsxMemberToMember(name) {
+  const obj = t.isJSXMemberExpression(name.object) ? jsxMemberToMember(name.object) : t.identifier(name.object.name);
+  return t.memberExpression(obj, t.identifier(name.property.name));
+}
+function processJsxText(value) {
+  if (!value.includes("\n")) return value;
+  return value.replace(/^[ \t]*\n[ \t]*/, "").replace(/[ \t]*\n[ \t]*$/, "").replace(/[ \t]*\n[ \t]*/g, " ");
+}
+function buildSolidMark(el, state) {
+  state.usedJsx = true;
+  const parts = [];
+  for (const c of el.children) {
+    if (t.isJSXText(c)) {
+      if (c.value.trim() === "") continue;
+      parts.push(c.value);
+    } else if (t.isJSXExpressionContainer(c)) {
+      if (t.isJSXEmptyExpression(c.expression)) continue;
+      parts.push(generate(c.expression).code);
+    } else {
+      parts.push(generate(c).code);
+    }
+  }
+  return t.callExpression(t.identifier("_jsx"), [
+    t.stringLiteral("solid"),
+    t.objectExpression([
+      t.objectProperty(
+        t.stringLiteral("children"),
+        t.arrayExpression(parts.map((p) => t.stringLiteral(p)))
+      )
+    ]),
+    t.identifier("undefined")
+  ]);
+}
+
+// src/babel-host.ts
+import * as babel from "@babel/core";
+function createBabelItem(plugin) {
+  return babel.createConfigItemSync(plugin, { type: "plugin" });
+}
+function transformWithBabel(code, filename, pluginItem) {
+  const result = babel.transformSync(code, {
+    filename,
+    plugins: [pluginItem],
+    parserOpts: { plugins: ["jsx", "typescript"] },
+    retainLines: true,
+    sourceMaps: true,
+    babelrc: false,
+    configFile: false
+  });
+  if (!result) return null;
+  return { code: result.code || code, map: result.map };
+}
+function createBabelTransform(plugin) {
+  const items = (Array.isArray(plugin) ? plugin : [plugin]).map((p) => createBabelItem(p));
+  return (code, filename) => {
+    const result = babel.transformSync(code, {
+      filename,
+      plugins: items,
+      parserOpts: { plugins: ["jsx", "typescript"] },
+      retainLines: true,
+      sourceMaps: true,
+      babelrc: false,
+      configFile: false
+    });
+    if (!result) return null;
+    return { code: result.code || code, map: result.map };
+  };
+}
+
+// src/solid-plugin.ts
+import { types as t2, parseSync } from "@babel/core";
+var solidVarCounter = 0;
+function solidPlugin() {
+  let usedSolid = false;
+  return {
+    visitor: {
+      Program: {
+        enter() {
+          usedSolid = false;
+          solidVarCounter = 0;
+        },
+        exit(path) {
+          path.traverse({
+            CallExpression(p) {
+              handleSolidCall(p, () => {
+                usedSolid = true;
+              });
+            }
+          });
+          if (!usedSolid) return;
+          const hasImport = path.node.body.some(
+            (n) => t2.isImportDeclaration(n) && n.source.value === "@actview/core" && n.specifiers.some((s) => s.imported?.name === "solidGet")
+          );
+          if (!hasImport) {
+            path.node.body.unshift(
+              t2.importDeclaration(
+                ["solidGet", "createEffect", "mapArray"].map(
+                  (n) => t2.importSpecifier(t2.identifier(n), t2.identifier(n))
+                ),
+                t2.stringLiteral("@actview/core")
+              )
+            );
+          }
+        }
+      }
+    }
+  };
+}
+function handleSolidCall(path, markUsed) {
+  const node = path.node;
+  if (!(t2.isIdentifier(node.callee) && /^_?jsx/.test(node.callee.name))) return;
+  if (!(node.arguments[0] && t2.isStringLiteral(node.arguments[0], { value: "solid" }))) return;
+  const propsObj = node.arguments[1];
+  if (!t2.isObjectExpression(propsObj)) return;
+  const childrenProp = propsObj.properties.find(
+    (p) => t2.isObjectProperty(p) && t2.isStringLiteral(p.key, { value: "children" })
+  );
+  if (!childrenProp || !t2.isArrayExpression(childrenProp.value)) return;
+  const srcs = [];
+  for (const e of childrenProp.value.elements) {
+    if (e && t2.isStringLiteral(e)) srcs.push(e.value);
+  }
+  if (srcs.length === 0 || srcs.every((s) => !s.trim())) return;
+  const counter = { n: 0 };
+  const stmts = [];
+  try {
+    for (const src of srcs) {
+      const ast = parseSync(src, { parserOpts: { plugins: ["jsx", "typescript"] } });
+      if (!ast) return;
+      for (const st of ast.program.body) {
+        if (t2.isExpressionStatement(st)) {
+          compileSolidTop(st.expression, t2.identifier("container"), stmts, counter);
+        } else {
+          stmts.push(st);
+        }
+      }
+    }
+  } catch (e) {
+    console.error("[solid-plugin] compile error:", e?.message);
+    return;
+  }
+  if (stmts.length === 0) return;
+  markUsed();
+  const holderId = t2.identifier("_solid$$" + ++solidVarCounter);
+  const renderFn = path.getFunctionParent();
+  const setupFn = renderFn && renderFn.getFunctionParent();
+  const holderDecl = t2.variableDeclaration("const", [
+    t2.variableDeclarator(holderId, t2.objectExpression([]))
+  ]);
+  if (setupFn && t2.isFunction(setupFn.node)) {
+    setupFn.get("body").unshiftContainer("body", holderDecl);
+  } else {
+    const prog = path.findParent((p) => p.isProgram());
+    prog?.unshiftContainer("body", holderDecl);
+  }
+  path.replaceWith(
+    t2.callExpression(t2.identifier("solidGet"), [
+      holderId,
+      t2.arrowFunctionExpression(
+        [t2.identifier("container")],
+        t2.blockStatement(stmts)
+      )
+    ])
+  );
+}
+function compileSolidTop(expr, containerVar, stmts, counter) {
+  if (t2.isJSXElement(expr)) {
+    return compileSolidElement(expr, stmts, counter);
+  }
+  if (t2.isJSXFragment(expr)) {
+    compileSolidChildren(expr.children, containerVar, stmts, counter);
+    return null;
+  }
+  const mapCall = matchMapCall(expr);
+  if (mapCall) {
+    stmts.push(
+      t2.expressionStatement(
+        t2.callExpression(t2.identifier("mapArray"), [
+          t2.arrowFunctionExpression([], mapCall.listExpr),
+          containerVar,
+          compileMapArrow(mapCall.arrow, counter)
+        ])
+      )
+    );
+    return null;
+  }
+  const textVar = t2.identifier("_t" + ++counter.n);
+  stmts.push(
+    t2.variableDeclaration("const", [
+      t2.variableDeclarator(
+        textVar,
+        t2.callExpression(t2.memberExpression(t2.identifier("document"), t2.identifier("createTextNode")), [
+          t2.stringLiteral("")
+        ])
+      )
+    ])
+  );
+  stmts.push(
+    t2.expressionStatement(
+      t2.callExpression(t2.identifier("createEffect"), [
+        t2.arrowFunctionExpression(
+          [],
+          t2.assignmentExpression(
+            "=",
+            t2.memberExpression(textVar, t2.identifier("textContent")),
+            expr
+          )
+        )
+      ])
+    )
+  );
+  stmts.push(appendStmt(containerVar, textVar));
+  return null;
+}
+function compileSolidChildren(children, containerVar, stmts, counter) {
+  for (const c of children) {
+    if (t2.isJSXText(c)) {
+      if (c.value.trim() === "") continue;
+      const textVar = t2.identifier("_t" + ++counter.n);
+      stmts.push(
+        t2.variableDeclaration("const", [
+          t2.variableDeclarator(
+            textVar,
+            t2.callExpression(t2.memberExpression(t2.identifier("document"), t2.identifier("createTextNode")), [
+              t2.stringLiteral(c.value)
+            ])
+          )
+        ])
+      );
+      stmts.push(appendStmt(containerVar, textVar));
+    } else if (t2.isJSXExpressionContainer(c)) {
+      const expr = c.expression;
+      if (t2.isJSXEmptyExpression(expr)) continue;
+      const mapCall = matchMapCall(expr);
+      if (mapCall) {
+        stmts.push(
+          t2.expressionStatement(
+            t2.callExpression(t2.identifier("mapArray"), [
+              t2.arrowFunctionExpression([], mapCall.listExpr),
+              containerVar,
+              compileMapArrow(mapCall.arrow, counter)
+            ])
+          )
+        );
+      } else {
+        const textVar = t2.identifier("_t" + ++counter.n);
+        stmts.push(
+          t2.variableDeclaration("const", [
+            t2.variableDeclarator(
+              textVar,
+              t2.callExpression(t2.memberExpression(t2.identifier("document"), t2.identifier("createTextNode")), [
+                t2.stringLiteral("")
+              ])
+            )
+          ])
+        );
+        stmts.push(
+          t2.expressionStatement(
+            t2.callExpression(t2.identifier("createEffect"), [
+              t2.arrowFunctionExpression(
+                [],
+                t2.assignmentExpression(
+                  "=",
+                  t2.memberExpression(textVar, t2.identifier("textContent")),
+                  expr
+                )
+              )
+            ])
+          )
+        );
+        stmts.push(appendStmt(containerVar, textVar));
+      }
+    } else if (t2.isJSXElement(c)) {
+      const elVar = compileSolidElement(c, stmts, counter);
+      stmts.push(appendStmt(containerVar, elVar));
+    } else if (t2.isJSXFragment(c)) {
+      compileSolidChildren(c.children, containerVar, stmts, counter);
+    }
+  }
+}
+function compileSolidElement(el, stmts, counter) {
+  const name = el.openingElement.name;
+  const tag = t2.isJSXIdentifier(name) ? name.name : name.name;
+  const elVar = t2.identifier("_el" + ++counter.n);
+  stmts.push(
+    t2.variableDeclaration("const", [
+      t2.variableDeclarator(
+        elVar,
+        t2.callExpression(t2.memberExpression(t2.identifier("document"), t2.identifier("createElement")), [
+          t2.stringLiteral(tag)
+        ])
+      )
+    ])
+  );
+  for (const attr of el.openingElement.attributes) {
+    if (!t2.isJSXAttribute(attr)) continue;
+    const attrName = attr.name.name;
+    if (attrName === "key" || attrName === "ref" || attrName === "v-memo") continue;
+    if (/^on[A-Z]/.test(attrName)) {
+      const evt = attrName[2].toLowerCase() + attrName.slice(3);
+      const handler = attr.value?.expression ?? attr.value ?? t2.identifier("undefined");
+      stmts.push(
+        t2.expressionStatement(
+          t2.callExpression(t2.memberExpression(elVar, t2.identifier("addEventListener")), [
+            t2.stringLiteral(evt),
+            handler
+          ])
+        )
+      );
+      continue;
+    }
+    if (attr.value && t2.isJSXExpressionContainer(attr.value)) {
+      stmts.push(
+        t2.expressionStatement(
+          t2.callExpression(t2.identifier("createEffect"), [
+            t2.arrowFunctionExpression(
+              [],
+              t2.callExpression(t2.memberExpression(elVar, t2.identifier("setAttribute")), [
+                t2.stringLiteral(attrName),
+                attr.value.expression
+              ])
+            )
+          ])
+        )
+      );
+    } else {
+      const value = attr.value ? t2.isStringLiteral(attr.value) ? attr.value.value : true : true;
+      stmts.push(
+        t2.expressionStatement(
+          t2.callExpression(t2.memberExpression(elVar, t2.identifier("setAttribute")), [
+            t2.stringLiteral(attrName),
+            value === true ? t2.stringLiteral("true") : t2.stringLiteral(value)
+          ])
+        )
+      );
+    }
+  }
+  compileSolidChildren(el.children, elVar, stmts, counter);
+  return elVar;
+}
+function appendStmt(containerVar, childVar) {
+  return t2.expressionStatement(
+    t2.callExpression(t2.memberExpression(containerVar, t2.identifier("appendChild")), [childVar])
+  );
+}
+function matchMapCall(expr) {
+  if (t2.isCallExpression(expr) && t2.isMemberExpression(expr.callee) && t2.isIdentifier(expr.callee.property, { name: "map" }) && expr.arguments.length === 1 && t2.isArrowFunctionExpression(expr.arguments[0])) {
+    return { listExpr: expr.callee.object, arrow: expr.arguments[0] };
+  }
+  return null;
+}
+function compileMapArrow(arrow, counter) {
+  const stmts = [];
+  const bodyExpr = arrow.body;
+  if (t2.isJSXElement(bodyExpr)) {
+    const elVar = compileSolidElement(bodyExpr, stmts, counter);
+    stmts.push(t2.returnStatement(elVar));
+    return t2.arrowFunctionExpression(arrow.params, t2.blockStatement(stmts));
+  }
+  if (t2.isJSXFragment(bodyExpr)) {
+    return arrow;
+  }
+  return arrow;
+}
+export {
+  createBabelItem,
+  createBabelTransform,
+  defineComponentPlugin as default,
+  defineComponentPlugin,
+  solidPlugin,
+  transformWithBabel
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@actview/plugin-babel",
+  "version": "1.0.3",
+  "type": "module",
+  "description": "Babel 插件：JSX 组件自动 defineComponent 转换（ActView 编译核心，独立于 Vite 宿主）",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@babel/core": "^8.0.1",
+    "@babel/generator": "^8.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}