refactor: break down files

Author: antfu

src/proxy/_utils.ts

@@ -1,75 +1,14 @@
 import * as recast from "recast";
 import { MagicastError } from "../error";
 import type { ESNode } from "../types";
-import { proxifyArray } from "./array";
-import { proxifyFunctionCall } from "./function-call";
-import { proxifyObject } from "./object";
-import { ProxyUtils, Proxified, ProxifiedModule } from "./types";
+import { ProxyUtils, Proxified } from "./types";
 
 const b = recast.types.builders;
 
-const literalTypes = new Set([
-  "Literal",
-  "StringLiteral",
-  "NumericLiteral",
-  "BooleanLiteral",
-  "NullLiteral",
-  "RegExpLiteral",
-  "BigIntLiteral",
-]);
-
-const literals = new Set([
-  "string",
-  "number",
-  "boolean",
-  "bigint",
-  "symbol",
-  "undefined",
-]);
-
-const _cache = new WeakMap<ESNode, Proxified<any>>();
-
 export function isValidPropName(name: string) {
   return /^[$A-Z_a-z][\w$]*$/.test(name);
 }
 
-export function proxify<T>(node: ESNode, mod?: ProxifiedModule): Proxified<T> {
-  if (literals.has(typeof node)) {
-    return node as any;
-  }
-  if (literalTypes.has(node.type)) {
-    return (node as any).value as any;
-  }
-
-  if (_cache.has(node)) {
-    return _cache.get(node) as Proxified<T>;
-  }
-
-  let proxy: Proxified<T>;
-  switch (node.type) {
-    case "ObjectExpression": {
-      proxy = proxifyObject<T>(node, mod);
-      break;
-    }
-    case "ArrayExpression": {
-      proxy = proxifyArray<T>(node, mod);
-      break;
-    }
-    case "CallExpression": {
-      proxy = proxifyFunctionCall(node, mod);
-      break;
-    }
-    default:
-      throw new MagicastError(`Casting "${node.type}" is not supported`, {
-        ast: node,
-        code: mod?.$code,
-      });
-  }
-
-  _cache.set(node, proxy);
-  return proxy;
-}
-
 const PROXY_KEY = "__magicast_proxy";
 
 export function literalToAst(value: any, seen = new Set()): ESNode {

src/proxy/array.ts

@@ -1,5 +1,6 @@
 import { ESNode } from "../types";
-import { literalToAst, createProxy, proxify } from "./_utils";
+import { literalToAst, createProxy } from "./_utils";
+import { proxify } from "./proxify";
 import { Proxified, ProxifiedModule } from "./types";
 
 export function proxifyArrayElements<T extends object>(

src/proxy/exports.ts

@@ -1,6 +1,7 @@
 import * as recast from "recast";
 import { Program } from "@babel/types";
-import { createProxy, literalToAst, proxify } from "./_utils";
+import { createProxy, literalToAst } from "./_utils";
+import { proxify } from "./proxify";
 import { ProxifiedModule } from "./types";
 
 const b = recast.types.builders;

src/proxy/object.ts

@@ -1,7 +1,8 @@
 import * as recast from "recast";
 import { ESNode } from "../types";
 import { MagicastError } from "../error";
-import { literalToAst, createProxy, proxify, isValidPropName } from "./_utils";
+import { literalToAst, createProxy, isValidPropName } from "./_utils";
+import { proxify } from "./proxify";
 import { Proxified, ProxifiedModule } from "./types";
 
 const b = recast.types.builders;

src/proxy/proxify.ts

@@ -0,0 +1,64 @@
+import { MagicastError } from "../error";
+import { ESNode } from "../types";
+import { proxifyArray } from "./array";
+import { proxifyFunctionCall } from "./function-call";
+import { proxifyObject } from "./object";
+import { Proxified, ProxifiedModule } from "./types";
+
+const _literalTypes = new Set([
+  "Literal",
+  "StringLiteral",
+  "NumericLiteral",
+  "BooleanLiteral",
+  "NullLiteral",
+  "RegExpLiteral",
+  "BigIntLiteral",
+]);
+
+const _literals = new Set([
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "symbol",
+  "undefined",
+]);
+
+const _cache = new WeakMap<ESNode, Proxified<any>>();
+
+export function proxify<T>(node: ESNode, mod?: ProxifiedModule): Proxified<T> {
+  if (_literals.has(typeof node)) {
+    return node as any;
+  }
+  if (_literalTypes.has(node.type)) {
+    return (node as any).value as any;
+  }
+
+  if (_cache.has(node)) {
+    return _cache.get(node) as Proxified<T>;
+  }
+
+  let proxy: Proxified<T>;
+  switch (node.type) {
+    case "ObjectExpression": {
+      proxy = proxifyObject<T>(node, mod);
+      break;
+    }
+    case "ArrayExpression": {
+      proxy = proxifyArray<T>(node, mod);
+      break;
+    }
+    case "CallExpression": {
+      proxy = proxifyFunctionCall(node, mod);
+      break;
+    }
+    default:
+      throw new MagicastError(`Casting "${node.type}" is not supported`, {
+        ast: node,
+        code: mod?.$code,
+      });
+  }
+
+  _cache.set(node, proxy);
+  return proxy;
+}