babel-plugin-define-variables/esm/index.js

一个类似 webpack.DefinePlugin 的 Babel 插件，用于在编译时定义全局变量和常量

"use strict";

var hash = require('hash-sum');

var _require = require('./utils'),
    getConstCache = _require.getConstCache,
    var2Expression = _require.var2Expression,
    expr2str = _require.expr2str,
    getPackage = _require.getPackage,
    mergeObject = _require.mergeObject,
    hasOwnProp = _require.hasOwnProp;

function createHash(filename, pkg) {
  if (pkg) filename = "".concat(pkg.name, "!").concat(filename);
  return "".concat(hash(filename.replace(/\\/g, '/')));
}

module.exports = function (_ref) {
  var t = _ref.types;
  var options = {
    builtIns: {
      filename: true,
      filehash: true,
      dirname: true,
      now: true,
      timestamp: true,
      packagename: true,
      packageversion: true
    }
  };

  function IdentifierVisitor(path, _ref2) {
    var opts = _ref2.opts,
        cache = _ref2.cache;
    var parent = path.parent;
    if (!parent) return;
    if (['FunctionDeclaration', 'ClassMethod', 'ObjectMethod'].includes(parent.type)) return;
    if (parent.type === 'ObjectProperty' && parent.key === path.node) return;
    if (parent.type === 'VariableDeclarator' && parent.id === path.node) return;
    var identifier = expr2str(path.node);

    if (parent.type === 'MemberExpression') {
      var parentPath = path.parentPath;

      while (parentPath && parentPath.node.type === 'MemberExpression' && path.node === parentPath.node.property) {
        identifier = "".concat(expr2str(parentPath.node.object), ".").concat(identifier);
        path = parentPath;
        parentPath = parentPath.parentPath;
      }
    } else if (parent.type === 'CallExpression' && expr2str(parent.callee) === identifier) {
      if (identifier !== '__packageversion__' || !parent.arguments.length || !t.isStringLiteral(parent.arguments[0])) return;
      path = path.parentPath;
      var packageName = expr2str(path.node.arguments[0]);

      var packagePath = packageName && require.resolve(packageName);

      var pkg = getPackage(packagePath);
      path.replaceWith(t.stringLiteral(pkg ? pkg.version : ''));
      return;
    }

    var defines = opts && opts.defines || {};

    if (options.builtIns.filename && identifier === '__filename__') {
      path.replaceWith(t.stringLiteral(cache.filename));
    } else if (options.builtIns.dirname && identifier === '__dirname__') {
      path.replaceWith(t.stringLiteral(cache.dirname));
    } else if (options.builtIns.now && identifier === '__now__') {
      path.replaceWith(t.stringLiteral(cache.now));
    } else if (options.builtIns.timestamp && identifier === '__timestamp__') {
      path.replaceWith(t.numericLiteral(Date.now()));
    } else if (options.builtIns.filehash && identifier === '__filehash__') {
      path.replaceWith(t.stringLiteral(createHash(cache.filename, cache.pkg)));
    } else if (hasOwnProp(defines, identifier)) {
      path.replaceWith(var2Expression(defines[identifier]));
    } else if (cache.pkg) {
      if (options.builtIns.packagename && identifier === '__packagename__') {
        path.replaceWith(t.stringLiteral(cache.pkg.name));
      } else if (options.builtIns.packageversion && identifier === '__packageversion__') {
        path.replaceWith(t.stringLiteral(cache.pkg.version));
      }
    }
  }

  return {
    visitor: {
      Program: {
        enter: function enter(path, state) {
          var filename = state.file.opts.filename,
              opts = state.opts;
          var cache = getConstCache(filename);
          mergeObject(options, opts);
          path.traverse({
            Identifier: IdentifierVisitor
          }, {
            cache: cache,
            opts: opts
          });
        }
      }
    }
  };
};