Inline & simplify @babel/helper-define-map (#15274)

* Move functions to inline file

* Simplify code

* Delete `@babel/helper-define-map`

* `make code-quality`

packages/babel-plugin-transform-property-mutators/package.json

@@ -17,7 +17,6 @@
     "babel-plugin"
   ],
   "dependencies": {
-    "@babel/helper-define-map": "workspace:^",
     "@babel/helper-plugin-utils": "workspace:^"
   },
   "peerDependencies": {

packages/babel-plugin-transform-property-mutators/src/define-map.ts

@@ -0,0 +1,66 @@
+import { types as t } from "@babel/core";
+
+type DefineMap = {
+  _inherits: t.Node[];
+  _key: t.Expression;
+  get?: t.Expression;
+  set?: t.Expression;
+  kind: "get" | "set";
+};
+
+export type MutatorMap = Record<string, DefineMap>;
+
+export function pushAccessor(
+  mutatorMap: MutatorMap,
+  node: t.ObjectMethod & { kind: "get" | "set"; computed: false },
+) {
+  const alias = t.toKeyAlias(node);
+  const map = (mutatorMap[alias] ??= {
+    _inherits: [],
+    _key: node.key,
+  } as DefineMap);
+
+  map._inherits.push(node);
+
+  const value = t.functionExpression(
+    null,
+    node.params,
+    node.body,
+    node.generator,
+    node.async,
+  );
+  value.returnType = node.returnType;
+  t.inheritsComments(value, node);
+  map[node.kind] = value;
+
+  return map;
+}
+
+export function toDefineObject(mutatorMap: any) {
+  const objExpr = t.objectExpression([]);
+
+  Object.keys(mutatorMap).forEach(function (mutatorMapKey) {
+    const map = mutatorMap[mutatorMapKey];
+    map.configurable = t.booleanLiteral(true);
+    map.enumerable = t.booleanLiteral(true);
+
+    const mapNode = t.objectExpression([]);
+
+    const propNode = t.objectProperty(map._key, mapNode, map._computed);
+
+    Object.keys(map).forEach(function (key) {
+      const node = map[key];
+      if (key[0] === "_") return;
+
+      const prop = t.objectProperty(t.identifier(key), node);
+      t.inheritsComments(prop, node);
+      t.removeComments(node);
+
+      mapNode.properties.push(prop);
+    });
+
+    objExpr.properties.push(propNode);
+  });
+
+  return objExpr;
+}

packages/babel-plugin-transform-property-mutators/src/index.ts

@@ -1,5 +1,5 @@
 import { declare } from "@babel/helper-plugin-utils";
-import * as defineMap from "@babel/helper-define-map";
+import { type MutatorMap, pushAccessor, toDefineObject } from "./define-map";
 import { types as t } from "@babel/core";
 
 export default declare(api => {
@@ -9,18 +9,20 @@ export default declare(api => {
     name: "transform-property-mutators",
 
     visitor: {
-      ObjectExpression(path, { file }) {
+      ObjectExpression(path) {
         const { node } = path;
-        let mutatorMap: defineMap.MutatorMap | void;
+        let mutatorMap: MutatorMap | undefined;
         const newProperties = node.properties.filter(function (prop) {
-          if (t.isObjectMethod(prop)) {
-            if (prop.kind === "get" || prop.kind === "set") {
-              mutatorMap ??= {};
-              if (!prop.computed) {
-                defineMap.push(mutatorMap, prop, null, file);
-                return false;
-              }
-            }
+          if (
+            t.isObjectMethod(prop) &&
+            !prop.computed &&
+            (prop.kind === "get" || prop.kind === "set")
+          ) {
+            pushAccessor(
+              (mutatorMap ??= {}),
+              prop as t.ObjectMethod & { kind: "get" | "set"; computed: false },
+            );
+            return false;
           }
           return true;
         });
@@ -37,7 +39,7 @@ export default declare(api => {
               t.identifier("Object"),
               t.identifier("defineProperties"),
             ),
-            [node, defineMap.toDefineObject(mutatorMap)],
+            [node, toDefineObject(mutatorMap)],
           ),
         );
       },