@babel/plugin-transform-proto-to-assign/lib/index.js

Babel plugin for turning __proto__ into a shallow property clone

import { declare } from '@babel/helper-plugin-utils';
import { types } from '@babel/core';

const index = declare(api => {
  api.assertVersion("^7.0.0-0 || ^8.0.0");
  function isProtoKey(node) {
    return !types.isSpreadElement(node) && types.isStringLiteral(types.toComputedKey(node, node.key), {
      value: "__proto__"
    });
  }
  function isProtoAssignmentExpression(node) {
    const left = node;
    return types.isMemberExpression(left) && types.isStringLiteral(types.toComputedKey(left, left.property), {
      value: "__proto__"
    });
  }
  function buildDefaultsCallExpression(expr, ref, file) {
    return types.expressionStatement(types.callExpression(file.addHelper("defaults"), [ref, expr.right]));
  }
  return {
    name: "transform-proto-to-assign",
    visitor: {
      AssignmentExpression(path, {
        file
      }) {
        if (!isProtoAssignmentExpression(path.node.left)) return;
        const nodes = [];
        const left = path.node.left.object;
        const temp = path.scope.maybeGenerateMemoised(left);
        if (temp) {
          nodes.push(types.expressionStatement(types.assignmentExpression("=", temp, left)));
        }
        nodes.push(buildDefaultsCallExpression(path.node, types.cloneNode(temp || left), file));
        if (temp) nodes.push(types.cloneNode(temp));
        path.replaceWithMultiple(nodes);
      },
      ExpressionStatement(path, {
        file
      }) {
        const expr = path.node.expression;
        if (!types.isAssignmentExpression(expr, {
          operator: "="
        })) return;
        if (isProtoAssignmentExpression(expr.left)) {
          path.replaceWith(buildDefaultsCallExpression(expr, expr.left.object, file));
        }
      },
      ObjectExpression(path, {
        file
      }) {
        let proto;
        const {
          node
        } = path;
        const {
          properties
        } = node;
        for (let i = 0; i < properties.length; i++) {
          const prop = properties[i];
          if (isProtoKey(prop)) {
            proto = prop.value;
            properties.splice(i, 1);
            break;
          }
        }
        if (proto) {
          const args = [types.objectExpression([]), proto];
          if (node.properties.length) args.push(node);
          path.replaceWith(types.callExpression(file.addHelper("extends"), args));
        }
      }
    }
  };
});

export { index as default };
//# sourceMappingURL=index.js.map