build-boiler/gulp/tasks/webpack/make-webpack-config.js

Build Boilerplate using Webpack, Eslint, Assemble, Nunjucks, and BrowserSync

'use strict';

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

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 (config) {
  var ENV = config.ENV;
  var quick = config.quick;
  var sources = config.sources;
  var isMainTask = config.isMainTask;
  var utils = config.utils;
  var environment = config.environment;
  var publicPath = config.publicPath;
  var webpackConfig = config.webpackConfig;
  var entry = sources.entry;
  var srcDir = sources.srcDir;
  var scriptDir = sources.scriptDir;
  var buildDir = sources.buildDir;
  var globalBundleName = sources.globalBundleName;
  var mainBundleName = sources.mainBundleName;
  var alias = webpackConfig.alias;
  var _webpackConfig$base = webpackConfig.base;
  var baseConfig = _webpackConfig$base === undefined ? {} : _webpackConfig$base;
  var _webpackConfig$babel = webpackConfig.babel;
  var babelParentConfig = _webpackConfig$babel === undefined ? {} : _webpackConfig$babel;
  var _webpackConfig$module = webpackConfig.moduleRoot;
  var parentModuleRoot = _webpackConfig$module === undefined ? [] : _webpackConfig$module;
  var node = webpackConfig.node;
  var hashFunction = webpackConfig.hashFunction;
  var hot = webpackConfig.hot;
  var expose = webpackConfig.expose;
  var multipleBundles = webpackConfig.multipleBundles;
  var paths = webpackConfig.paths;
  var vendors = webpackConfig.vendors;
  var jsBundleName = paths.jsBundleName;
  var isDev = environment.isDev;
  var isIE = environment.isIE;
  var addbase = utils.addbase;
  var addroot = utils.addroot;

  var _getLoaderPluginConfi = (0, _getLoaderPluginConfig2.default)(config);

  var isServer = _getLoaderPluginConfi.isServer;
  var parentExternals = _getLoaderPluginConfi.externals;
  var preLoaders = _getLoaderPluginConfi.preLoaders;
  var loaders = _getLoaderPluginConfi.loaders;
  var postLoaders = _getLoaderPluginConfi.postLoaders;
  var plugins = _getLoaderPluginConfi.plugins;
  var rules = _getLoaderPluginConfi.rules;
  var configFile = _getLoaderPluginConfi.configFile;


  var defaultExternals = {
    'sinon': 'window.sinon'
  };
  var externals = Object.assign({}, defaultExternals, parentExternals);

  var defaultRoot = [addbase(srcDir, scriptDir), addroot('node_modules'), 'node_modules'];

  var moduleRoot = _lodash2.default.union(defaultRoot, parentModuleRoot);
  var loaderRoot = [addroot('node_modules'), addbase('node_modules')];

  var defaultConfig = _extends({
    alias: alias,
    externals: externals,
    eslint: {
      rules: rules,
      configFile: configFile,
      formatter: _eslintFriendlyFormatter2.default,
      emitError: false,
      emitWarning: false,
      failOnWarning: !isDev,
      failOnError: !isDev
    },
    resolveLoader: {
      //fallback for Webpack 1
      modulesDirectories: loaderRoot,
      modules: loaderRoot
    },
    resolve: {
      extensions: ['', '.js', '.json', '.jsx', '.html', '.css', '.scss', '.yaml', '.yml'],
      //fallback for Webpack 1
      modulesDirectories: moduleRoot,
      modules: moduleRoot
    },
    node: node
  }, baseConfig);

  var commons = { vendors: vendors };
  var context = addbase(srcDir);

  var configFn = {
    development: function development(isProd) {
      var devPlugins = [new _webpack2.default.HotModuleReplacementPlugin()];

      var hmrOpts = ['path=' + publicPath + '__webpack_hmr', 'reload=true'];
      var hotEntry = ['webpack-hot-middleware/client?' + hmrOpts.join('&')];
      var taskEntry = undefined;

      if (isMainTask) {
        (function () {

          /*eslint no-inner-declarations:0*/

          var manageAdditions = function manageAdditions(mainBundle) {
            var method = arguments.length <= 1 || arguments[1] === undefined ? 'unshift' : arguments[1];
            var omitPolyfill = babelParentConfig.omitPolyfill;

            var additions = Object.keys(expose);

            if (!omitPolyfill && mainBundle.indexOf('babel-polyfill') === -1) {
              additions.unshift('babel-polyfill');
            }
            //otherwise load the modules we want to expose
            //and the babel-polyfill to support async function, etc.
            mainBundle[method].apply(mainBundle, _toConsumableArray(additions));

            if (hasShims) {
              mainBundle[method](shimFile);
            }
          };

          /**
           * build a vendor bundle if specified in the top level config
           */


          taskEntry = _lodash2.default.omit(entry, globalBundleName);

          /**
           * If a shims file exists compile it with the `entry` or `vendors`
           */
          var shimFile = addbase(srcDir, scriptDir, 'shims.js');
          var hasShims = _fs2.default.existsSync(shimFile);
          var omitEntry = undefined,
              multiBase = undefined,
              glob = undefined,
              buildMultiBundles = undefined;

          if (_lodash2.default.isPlainObject(multipleBundles)) {
            omitEntry = multipleBundles.omitEntry;
            multiBase = multipleBundles.base;
            glob = multipleBundles.glob;

            buildMultiBundles = true;
          } else {
            buildMultiBundles = multipleBundles;
          }if (buildMultiBundles) {
            _lodash2.default.assign(taskEntry, commons);

            var bundle = taskEntry.vendors;

            manageAdditions(bundle, 'push');

            if (omitEntry) {
              bundle.push.apply(bundle, _toConsumableArray(taskEntry[mainBundleName]));
              taskEntry = _lodash2.default.omit(taskEntry, mainBundleName);
            }

            var childEntries = (0, _makeMultipleEntries2.default)(config, {
              glob: glob,
              cwd: multiBase || context
            });

            _lodash2.default.assign(taskEntry, childEntries);
          } else {
            var bundle = taskEntry[mainBundleName];

            manageAdditions(bundle, 'unshift');
          }

          /**
           * Add the hot modules if not doing a prod build
           */
          if (!isProd) {
            if (!isIE && hot) {
              Object.keys(taskEntry).forEach(function (bundleName) {
                var _taskEntry$bundleName;

                (_taskEntry$bundleName = taskEntry[bundleName]).unshift.apply(_taskEntry$bundleName, hotEntry);
              });
            }

            plugins.push.apply(plugins, devPlugins);
          }
        })();
      } else {
        taskEntry = _lodash2.default.omit(entry, mainBundleName);
      }

      var devConfig = {
        context: context,
        cache: isDev,
        debug: isDev,
        entry: taskEntry,
        output: {
          path: addbase(buildDir),
          publicPath: publicPath,
          filename: (0, _path.join)('js', jsBundleName),
          hashFunction: hashFunction
        },
        module: {
          preLoaders: preLoaders,
          loaders: loaders,
          postLoaders: postLoaders
        },
        plugins: plugins,
        postcss: [(0, _autoprefixer2.default)({
          browsers: ['last 2 versions', 'Explorer >= 9', 'Safari >= 7', 'Opera >= 12', 'iOS >= 5', 'Android >= 3'],
          cascade: isDev
        })],
        devtool: 'source-map'
      };

      return _lodash2.default.merge({}, defaultConfig, devConfig);
    },
    production: function production() {
      var makeDevConfig = this.development;
      var prodConfig = makeDevConfig(true);

      if (!quick) {
        prodConfig.plugins.push(new _webpack2.default.optimize.UglifyJsPlugin({
          output: {
            comments: false
          },
          compress: {
            warnings: false
          }
        }), new _webpack2.default.optimize.DedupePlugin());
      }

      return prodConfig;
    },
    server: function server() {
      var _config$isomorphic = config.isomorphic;
      var isomorphic = _config$isomorphic === undefined ? {} : _config$isomorphic;
      var context = isomorphic.context;
      var devPort = sources.devPort;
      var devHost = sources.devHost;
      var branch = environment.branch;
      var assetPath = environment.asset_path;

      var bsPath = 'http://' + devHost + ':' + devPort + '/';
      var publicPath = _lodash2.default.isUndefined(branch) ? bsPath : assetPath + '/';
      var _isomorphic$modules = isomorphic.modules;
      var modules = _isomorphic$modules === undefined ? {} : _isomorphic$modules;
      var target = modules.target;

      //HACK: for issue with external jquery in commonjs
      //http://stackoverflow.com/questions/22530254/webpack-and-external-libraries

      var alias = Object.keys(externals || {}).reduce(function (acc, key) {
        return _extends({}, acc, _defineProperty({}, key, (0, _path.join)(__dirname, 'mocks', 'noop')));
      }, {});

      var serverExternals = (0, _gatherCommonjsModules2.default)(config);

      var serverConfig = {
        externals: serverExternals,
        context: context,
        entry: entry,
        output: {
          path: addbase(buildDir),
          publicPath: publicPath,
          filename: (0, _path.join)('js', jsBundleName),
          libraryTarget: 'commonjs2'
        },
        module: {
          loaders: loaders
        },
        resolve: {
          alias: alias
        },
        plugins: plugins,
        target: target
      };

      return _lodash2.default.merge({}, _lodash2.default.omit(defaultConfig, ['externals']), serverConfig);
    }
  };

  return isServer ? configFn.server() : configFn[ENV]();
};

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _path = require('path');

var _webpack = require('webpack');

var _webpack2 = _interopRequireDefault(_webpack);

var _autoprefixer = require('autoprefixer');

var _autoprefixer2 = _interopRequireDefault(_autoprefixer);

var _eslintFriendlyFormatter = require('eslint-friendly-formatter');

var _eslintFriendlyFormatter2 = _interopRequireDefault(_eslintFriendlyFormatter);

var _getLoaderPluginConfig = require('./get-loader-plugin-config');

var _getLoaderPluginConfig2 = _interopRequireDefault(_getLoaderPluginConfig);

var _gatherCommonjsModules = require('./gather-commonjs-modules');

var _gatherCommonjsModules2 = _interopRequireDefault(_gatherCommonjsModules);

var _makeMultipleEntries = require('./make-multiple-entries');

var _makeMultipleEntries2 = _interopRequireDefault(_makeMultipleEntries);

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

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

module.exports = exports['default'];