@faber1999/vite-plugin-axon 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { Plugin } from 'vite';
+
+/**
+ * vite-plugin-axon
+ *
+ * Transforms JSX attribute expressions that contain reactive calls into arrow
+ * functions, so that axon's h() can pick them up as reactive props.
+ *
+ * Before:  class={`foo ${active() ? 'bar' : 'baz'}`}
+ * After:   class={() => `foo ${active() ? 'bar' : 'baz'}`}
+ *
+ * Before:  disabled={isDisabled()}
+ * After:   disabled={() => isDisabled()}
+ *
+ * Rules:
+ *   - Only JSX attributes (not children — those are already functions in signal patterns)
+ *   - Skip event handlers (on*)
+ *   - Skip expressions that are already arrow functions or function expressions
+ *   - Only wrap when the expression contains at least one CallExpression
+ */
+
+declare function axonPlugin(): Plugin;
+
+export { axonPlugin as default };

package/dist/index.js

@@ -0,0 +1,80 @@
+// src/index.ts
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import _generate from "@babel/generator";
+import * as t from "@babel/types";
+var traverse = _traverse.default ?? _traverse;
+var generate = _generate.default ?? _generate;
+function containsCall(node) {
+  if (t.isCallExpression(node)) return true;
+  if (t.isTemplateLiteral(node)) {
+    return node.expressions.some((expr) => containsCall(expr));
+  }
+  if (t.isConditionalExpression(node)) {
+    return containsCall(node.test) || containsCall(node.consequent) || containsCall(node.alternate);
+  }
+  if (t.isLogicalExpression(node) || t.isBinaryExpression(node)) {
+    return containsCall(node.left) || containsCall(node.right);
+  }
+  if (t.isUnaryExpression(node)) {
+    return containsCall(node.argument);
+  }
+  if (t.isMemberExpression(node)) {
+    return containsCall(node.object);
+  }
+  if (t.isArrayExpression(node)) {
+    return node.elements.some((el) => el != null && containsCall(el));
+  }
+  if (t.isObjectExpression(node)) {
+    return node.properties.some((prop) => {
+      if (t.isObjectProperty(prop)) return containsCall(prop.value);
+      return false;
+    });
+  }
+  return false;
+}
+function shouldSkip(attrName, valueNode) {
+  if (attrName.startsWith("on") && attrName.length > 2) return true;
+  if (attrName === "ref") return true;
+  if (t.isArrowFunctionExpression(valueNode)) return true;
+  if (t.isFunctionExpression(valueNode)) return true;
+  return false;
+}
+function axonPlugin() {
+  return {
+    name: "vite-plugin-axon",
+    enforce: "pre",
+    transform(code, id) {
+      if (!id.endsWith(".jsx") && !id.endsWith(".tsx")) return null;
+      let ast;
+      try {
+        ast = parse(code, {
+          sourceType: "module",
+          plugins: ["jsx", "typescript"]
+        });
+      } catch {
+        return null;
+      }
+      let changed = false;
+      traverse(ast, {
+        JSXAttribute(path) {
+          const { name, value } = path.node;
+          const attrName = t.isJSXIdentifier(name) ? name.name : `${name.namespace.name}:${name.name.name}`;
+          if (!t.isJSXExpressionContainer(value)) return;
+          const expr = value.expression;
+          if (t.isJSXEmptyExpression(expr)) return;
+          if (shouldSkip(attrName, expr)) return;
+          if (!containsCall(expr)) return;
+          value.expression = t.arrowFunctionExpression([], expr);
+          changed = true;
+        }
+      });
+      if (!changed) return null;
+      const result = generate(ast, { retainLines: true }, code);
+      return { code: result.code, map: result.map };
+    }
+  };
+}
+export {
+  axonPlugin as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faber1999/vite-plugin-axon",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Vite plugin for axon.js — auto-wraps reactive JSX expressions in arrow functions",
   "author": "Faber Grajales Hincapié <faber1999> (https://github.com/faber1999)",
   "repository": {