babel-minify/lib/index.js

'use strict';

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

var _babelCore = require('babel-core');

var _babelPluginTransformMangle = require('babel-plugin-transform-mangle');

var _babelPluginTransformMangle2 = _interopRequireDefault(_babelPluginTransformMangle);

var _babelPluginTransformEvaluate = require('babel-plugin-transform-evaluate');

var _babelPluginTransformEvaluate2 = _interopRequireDefault(_babelPluginTransformEvaluate);

var _babelPluginTransformConditionals = require('babel-plugin-transform-conditionals');

var _babelPluginTransformConditionals2 = _interopRequireDefault(_babelPluginTransformConditionals);

var _babelPluginTransformRemoveDebugger = require('babel-plugin-transform-remove-debugger');

var _babelPluginTransformRemoveDebugger2 = _interopRequireDefault(_babelPluginTransformRemoveDebugger);

var _babelPluginTransformRemoveConsole = require('babel-plugin-transform-remove-console');

var _babelPluginTransformRemoveConsole2 = _interopRequireDefault(_babelPluginTransformRemoveConsole);

var _babelPluginTransformDeadCodeElimination = require('babel-plugin-transform-dead-code-elimination');

var _babelPluginTransformDeadCodeElimination2 = _interopRequireDefault(_babelPluginTransformDeadCodeElimination);

var _babelPluginTransformMemberExpressionLiterals = require('babel-plugin-transform-member-expression-literals');

var _babelPluginTransformMemberExpressionLiterals2 = _interopRequireDefault(_babelPluginTransformMemberExpressionLiterals);

var _babelPluginTransformMergeSiblingVariables = require('babel-plugin-transform-merge-sibling-variables');

var _babelPluginTransformMergeSiblingVariables2 = _interopRequireDefault(_babelPluginTransformMergeSiblingVariables);

var _babelPluginTransformMinifyBooleans = require('babel-plugin-transform-minify-booleans');

var _babelPluginTransformMinifyBooleans2 = _interopRequireDefault(_babelPluginTransformMinifyBooleans);

var _babelPluginTransformPropertyLiterals = require('babel-plugin-transform-property-literals');

var _babelPluginTransformPropertyLiterals2 = _interopRequireDefault(_babelPluginTransformPropertyLiterals);

var _babelPluginTransformSimplifyComparisonOperators = require('babel-plugin-transform-simplify-comparison-operators');

var _babelPluginTransformSimplifyComparisonOperators2 = _interopRequireDefault(_babelPluginTransformSimplifyComparisonOperators);

var _babelPluginTransformUndefinedToVoid = require('babel-plugin-transform-undefined-to-void');

var _babelPluginTransformUndefinedToVoid2 = _interopRequireDefault(_babelPluginTransformUndefinedToVoid);

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

// plugins


Error.stackTraceLimit = Infinity;
/**
 * The main function of the minifier
 * @function
 */
function BabelMinify(inputCode) {
  var _ref = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

  var _ref$mangle = _ref.mangle;
  let mangle = _ref$mangle === undefined ? true : _ref$mangle;
  var _ref$mangle_globals = _ref.mangle_globals;
  let mangle_globals = _ref$mangle_globals === undefined ? false : _ref$mangle_globals;
  var _ref$dead_code = _ref.dead_code;
  let dead_code = _ref$dead_code === undefined ? false : _ref$dead_code;
  var _ref$conditionals = _ref.conditionals;
  let conditionals = _ref$conditionals === undefined ? true : _ref$conditionals;
  var _ref$evaluate = _ref.evaluate;
  let evaluate = _ref$evaluate === undefined ? true : _ref$evaluate;
  var _ref$drop_debugger = _ref.drop_debugger;
  let // eval constant expressions
  drop_debugger = _ref$drop_debugger === undefined ? false : _ref$drop_debugger;
  var _ref$drop_console = _ref.drop_console;
  let drop_console = _ref$drop_console === undefined ? false : _ref$drop_console;
  var _ref$properties = _ref.properties;
  let properties = _ref$properties === undefined ? true : _ref$properties;
  var _ref$join_vars = _ref.join_vars;
  let join_vars = _ref$join_vars === undefined ? true : _ref$join_vars;
  var _ref$booleans = _ref.booleans;
  let booleans = _ref$booleans === undefined ? true : _ref$booleans;
  var _ref$unsafe = _ref.unsafe;
  let unsafe = _ref$unsafe === undefined ? true : _ref$unsafe;
  var _ref$keep_fnames = _ref.keep_fnames;
  let keep_fnames = _ref$keep_fnames === undefined ? false : _ref$keep_fnames;
  var _ref$npasses = _ref.npasses;
  let

  // number of passes
  npasses = _ref$npasses === undefined ? 1 : _ref$npasses;
  var _ref$babelrc = _ref.babelrc;
  let

  // passed on to babel transform to tell whether to use babelrc
  babelrc = _ref$babelrc === undefined ? false : _ref$babelrc;
  var _ref$plugins = _ref.plugins;
  let

  // should there be any other plugins added to this build process
  plugins = _ref$plugins === undefined ? [] : _ref$plugins;
  var _ref$presets = _ref.presets;
  let

  // should there be any other presets
  presets = _ref$presets === undefined ? [] : _ref$presets;
  var _ref$minify = _ref.minify;
  let

  // if false, babel-minify can give a list of plugins to use as a preset
  minify = _ref$minify === undefined ? true : _ref$minify;


  if (typeof inputCode !== 'string' && minify) throw new Error('Invalid Input');

  /**
   * The final list of plugins that are applied in babel transform
   * This is the first list that's preffered in babel transform, the plugins
   * that go into this take one pass, plugins that prefer separate passes go into
   * the {finalPresets}
   * @type {Array}
   */
  let minifyPlugins = [];

  /**
   * The final list of presets that are applied in SEPARATE passes
   * @type {Array}
   */
  let passes = [];

  evaluate && minifyPlugins.push(_babelPluginTransformEvaluate2.default);
  drop_debugger && minifyPlugins.push(_babelPluginTransformRemoveDebugger2.default);
  drop_console && minifyPlugins.push(_babelPluginTransformRemoveConsole2.default);
  properties && minifyPlugins.push(_babelPluginTransformMemberExpressionLiterals2.default);
  properties && minifyPlugins.push(_babelPluginTransformPropertyLiterals2.default);
  join_vars && minifyPlugins.push(_babelPluginTransformMergeSiblingVariables2.default);
  booleans && minifyPlugins.push(_babelPluginTransformMinifyBooleans2.default);
  unsafe && minifyPlugins.push(_babelPluginTransformUndefinedToVoid2.default);
  unsafe && minifyPlugins.push(_babelPluginTransformSimplifyComparisonOperators2.default);

  /**
   * Append all user passed plugins to minifyPlugins
   */
  minifyPlugins = minifyPlugins.concat(plugins);

  /**
   * Things that remove code or replace code in a major way,
   * we just use then in separate presets to enable them to be
   * under separate passes
   */
  if (dead_code) {
    passes.push({ plugins: [_babelPluginTransformDeadCodeElimination2.default] });
  }
  if (conditionals) {
    passes.push({ plugins: [_babelPluginTransformConditionals2.default] });
  }

  /**
   * Append all user passed presets to passes
   */
  passes = passes.concat(presets);

  /**
   * Keep mangler to be in the last of the presets
   * I don't know why clearly, but mangler seems to disrupt everything, so
   * I just keep it as the last pass
   */
  if (mangle) {
    passes.push({
      plugins: [[_babelPluginTransformMangle2.default, {
        keep_fnames: keep_fnames,
        mangle_globals: mangle_globals
      }]]
    });
  }

  // if minify is false, return the plugins list to be used elsewhere
  // maybe move this to a separate file later
  if (!minify) return { plugins: minifyPlugins, presets: passes };

  let result = { code: inputCode };

  while (npasses-- > 0) {
    result = (0, _babelCore.transform)(result.code, {
      babelrc: babelrc,
      comments: false,
      compact: true,
      minified: true,
      passPerPreset: true,
      presets: passes,
      plugins: minifyPlugins
    });
  }

  return result.code;
}
module.exports = exports['default'];