babel-plugin-webpack-loaders/lib/plugin.js

'use strict';

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

exports.default = function (_ref3) {
  var t = _ref3.types;

  return {
    visitor: {
      CallExpression: function CallExpression(path, _ref4) {
        var filenameRelative = _ref4.file.opts.filenameRelative;
        var _ref4$opts = _ref4.opts;
        _ref4$opts = _ref4$opts === undefined ? {} : _ref4$opts;
        var _ref4$opts$config = _ref4$opts.config;
        var configPath = _ref4$opts$config === undefined ? './webpack.config.js' : _ref4$opts$config;
        var _ref4$opts$verbose = _ref4$opts.verbose;
        var verbose = _ref4$opts$verbose === undefined ? true : _ref4$opts$verbose;

        // don't process current plugin
        if (typeof getEnhancedResolver === 'undefined') {
          return;
        }

        var _path$node = path.node;
        var calleeName = _path$node.callee.name;
        var args = _path$node.arguments;


        if (calleeName !== 'require' || !args.length || !t.isStringLiteral(args[0])) {
          return;
        }

        var config = localInteropRequire((0, _path.resolve)(process.cwd(), configPath));
        if (Object.keys(config).length === 0) {
          // it's possible require calls inside webpack config or bad config
          return;
        }

        var _args = _slicedToArray(args, 1);

        var filePath = _args[0].value;

        // to support babel builds (babel-node works fine)

        var filenameAbs = (0, _path.resolve)(filenameRelative);

        var resolver = getEnhancedResolver(config);
        var fileAbsPath = resolver.resolveSync({}, (0, _path.dirname)(filenameAbs), filePath);

        if (config.module.loaders.some(function (l) {
          return l.test.test(filePath) || l.test.test(fileAbsPath);
        })) {
          var webPackResult = (0, _runWebPackSync2.default)({ path: fileAbsPath, configPath: configPath, config: config, verbose: verbose });

          var expr = processWebPackResult(webPackResult, config);

          if (expr !== null) {
            if (expr.type === 'FunctionExpression') {
              path.remove();
            } else {
              path.replaceWith(expr);
            }
          } else {
            path.remove();
          }
        }
      }
    }
  };
};

var _path = require('path');

var _enhancedResolve = require('enhanced-resolve');

var _babylon = require('babylon');

var _babelTraverse = require('babel-traverse');

var _babelTraverse2 = _interopRequireDefault(_babelTraverse);

var _runWebPackSync = require('./runWebPackSync');

var _runWebPackSync2 = _interopRequireDefault(_runWebPackSync);

var _memoize = require('./memoize');

var _memoize2 = _interopRequireDefault(_memoize);

var _babelTypes = require('babel-types');

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

var processWebPackResult = function processWebPackResult(webPackResult) {
  var _ref = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

  var _ref$output = _ref.output;
  _ref$output = _ref$output === undefined ? {} : _ref$output;
  var _ref$output$publicPat = _ref$output.publicPath;
  var publicPath = _ref$output$publicPat === undefined ? '' : _ref$output$publicPat;

  var webpackResultAst = (0, _babylon.parse)(webPackResult);
  var expr = null;

  // without ExtractTextPlugin css-loader result looks like `blabla.locals = {...blbala}`
  (0, _babelTraverse2.default)(webpackResultAst, {
    FunctionExpression: function FunctionExpression(pathFn) {
      if (pathFn.node.params.length >= 2 && pathFn.node.params[1].name === 'exports') {
        pathFn.traverse({
          AssignmentExpression: function AssignmentExpression(path) {
            if (path.node.left.property && path.node.left.property.name === 'locals') {
              expr = path.node.right;
            }
          }
        });
      }
    }
  });

  // with ExtractTextPlugin css-loader result looks like `module.exports = {...blbala}`
  if (expr === null) {
    (0, _babelTraverse2.default)(webpackResultAst, {
      FunctionExpression: function FunctionExpression(pathFn) {
        if (pathFn.node.params.length >= 2 && pathFn.node.params[1].name === 'exports') {
          pathFn.traverse({
            AssignmentExpression: function AssignmentExpression(path) {
              if (path.node.left.property && path.node.left.property.name === 'exports') {
                expr = path.node.right;
              }
            },
            BinaryExpression: function BinaryExpression(pathBin) {
              pathBin.traverse({
                MemberExpression: function MemberExpression(pathM) {
                  if (pathM.node.object.name === '__webpack_require__' && pathM.node.property.name === 'p') {
                    pathM.replaceWith((0, _babelTypes.StringLiteral)(publicPath)); // eslint-disable-line
                  }
                }
              });
            }
          });
        }
      }
    });
  }

  return _babelTraverse2.default.removeProperties(expr);
};

// memoize resolver instance
var getEnhancedResolver = (0, _memoize2.default)(function (_ref2) {
  var configResolve = _ref2.resolve;
  return _enhancedResolve.ResolverFactory.createResolver(_extends({
    fileSystem: new _enhancedResolve.SyncNodeJsInputFileSystem()
  }, configResolve));
});

var localInteropRequire = function localInteropRequire(path) {
  var res = require((0, _path.resolve)(process.cwd(), path));
  if ('default' in res) {
    return res.default;
  }
  return res;
};