feat: support ArrowFunctionExpression

README.md

@@ -109,7 +109,7 @@ const ast = mod.exports.default.$ast
 // do something with ast
 ```
 
-**Example:** Function parameters:
+**Example:** Function arguments:
 
 ```js
 import { parseModule, generateCode } from "magicast";

src/proxy/arrow-function-expression.ts

@@ -0,0 +1,30 @@
+import type {
+ ASTNode,
+ ProxifiedArrowFunctionExpression,
+ ProxifiedModule,
+} from "../types";
+import { MagicastError } from "../error";
+import { createProxy } from "./_utils";
+import { proxifyArrayElements } from "./array";
+import { proxify } from "./proxify";
+
+export function proxifyArrowFunctionExpression<T extends []>(
+ node: ASTNode,
+ mod?: ProxifiedModule,
+): ProxifiedArrowFunctionExpression {
+ if (node.type !== "ArrowFunctionExpression") {
+ throw new MagicastError("Not an arrow function expression");
+ }
+
+ const parametersProxy = proxifyArrayElements<T>(node, node.params, mod);
+
+ return createProxy(
+ node,
+ {
+ $type: "arrow-function-expression",
+ $params: parametersProxy,
+ $body: proxify(node.body, mod),
+ },
+ {},
+ ) as ProxifiedArrowFunctionExpression;
+}

src/proxy/proxify.ts

@@ -3,6 +3,7 @@ import { MagicastError } from "../error";
 import type { Proxified, ProxifiedModule, ProxifiedValue } from "./types";
 import { proxifyArray } from "./array";
 import { proxifyFunctionCall } from "./function-call";
+import { proxifyArrowFunctionExpression } from "./arrow-function-expression";
 import { proxifyObject } from "./object";
 import { proxifyNewExpression } from "./new-expression";
 import { proxifyIdentifier } from "./identifier";
@@ -36,6 +37,10 @@ export function proxify<T>(node: ASTNode, mod?: ProxifiedModule): Proxified<T> {
  proxy = proxifyFunctionCall(node, mod);
  break;
  }
+ case "ArrowFunctionExpression": {
+ proxy = proxifyArrowFunctionExpression(node, mod);
+ break;
+ }
  case "NewExpression": {
  proxy = proxifyNewExpression(node, mod);
  break;

src/proxy/types.ts

@@ -30,6 +30,13 @@ export type ProxifiedNewExpression<Args extends any[] = unknown[]> =
  $callee: string;
  };
 
+export type ProxifiedArrowFunctionExpression<Params extends any[] = unknown[]> =
+ ProxyBase & {
+ $type: "arrow-function-expression";
+ $params: ProxifiedArray<Params>;
+ $body: ProxifiedValue;
+ };
+
 export type ProxifiedObject<T extends object = object> = {
  [K in keyof T]: Proxified<T[K]>;
 } & ProxyBase & {
@@ -103,6 +110,7 @@ export type ProxifiedValue =
  | ProxifiedObject
  | ProxifiedModule
  | ProxifiedImportsMap
- | ProxifiedImportItem;
+ | ProxifiedImportItem
+ | ProxifiedArrowFunctionExpression;
 
 export type ProxyType = ProxifiedValue["$type"];

test/function-call.test.ts

@@ -98,4 +98,16 @@ describe("function-calls", () => {
 
  expect(await generate(mod2)).toEqual(await generate(mod1));
  });
+
+ it("arrow function parameters", () => {
+ const mod = parseModule(`
+ import { defineConfig } from 'vite'
+
+ export default defineConfig((config) => ({ mode: "test" }))
+ `);
+
+ expect(mod.exports.default.$args[0].$params[0].$name).toBe("config");
+ expect(mod.exports.default.$args[0].$body.$type).toBe("object");
+ expect(mod.exports.default.$args[0].$body.mode).toBe("test");
+ });
 });