babel-plugin-transform-charcodes/lib/index.js

Replace charcodes AOT

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = _default;

var charcodes = _interopRequireWildcard(require("charcodes"));

var _parser = require("@babel/parser");

var _traverse = _interopRequireDefault(require("@babel/traverse"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

function _default(babel) {
  var t = babel.types;

  function parseFunctionSource(str) {
    var root = (0, _parser.parse)(str, {
      sourceType: 'script'
    });
    return root.program.body[0];
  }

  function createInlineFunction(func, id) {
    (0, _traverse.default)(func, {
      noScope: true,
      Identifier: function Identifier(path) {
        var name = path.node.name;

        if (typeof charcodes[name] !== "undefined" && typeof charcodes[name] !== "function") {
          path.replaceWith(t.numericLiteral(charcodes[name]));
        }
      }
    });
    return t.variableDeclaration('var', [t.variableDeclarator(id, t.toExpression(func))]);
  }

  return {
    visitor: {
      ImportDeclaration: function ImportDeclaration(path, state) {
        if (path.node.source.value === "charcodes") {
          state.importedLocalName = path.node.specifiers[0].local.name;
          path.remove();
        }
      },
      MemberExpression: function MemberExpression(path, state) {
        if (typeof state.importedLocalName !== "undefined" && path.node.object.name == state.importedLocalName) {
          var rightName = path.node.property.name;
          var charCodeValue = charcodes[rightName];

          if (typeof charCodeValue === "undefined") {
            throw new Error("unknown key " + rightName);
          } else if (typeof charCodeValue !== "function") {
            path.replaceWith(t.numericLiteral(charCodeValue));
          } else {
            var fn = parseFunctionSource(charCodeValue.toString());
            var id = path.scope.generateUidIdentifier(rightName);

            state._toHoist.push(createInlineFunction(fn, id));

            path.replaceWith(id);
          }
        }
      },
      Program: {
        enter: function enter(path, state) {
          state._toHoist = [];
        },
        exit: function exit(path, state) {
          state._toHoist.forEach(function (x) {
            path.node.body.unshift(x);
          });
        }
      }
    }
  };
}