build-boiler/gulp/tasks/webpack/index.js

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

'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"); } }; }();

exports.default = function (gulp, plugins, config) {
  var _arguments = arguments;
  var sources = config.sources;
  var utils = config.utils;
  var environment = config.environment;
  var webpackConfig = config.webpackConfig;
  var mainBundleName = sources.mainBundleName;
  var isDev = environment.isDev;
  var isIE = environment.isIE;
  var assetPath = environment.asset_path;
  var branch = environment.branch;
  var parentMiddleware = webpackConfig.middleware;
  var hot = webpackConfig.hot;
  var getTaskName = utils.getTaskName;
  var buildDir = sources.buildDir;
  var devPort = sources.devPort;
  var devHost = sources.devHost;
  var hotPort = sources.hotPort;
  var gutil = plugins.gutil;
  var app = plugins.app;

  var publicPath = undefined;

  return function (cb) {
    var taskName = getTaskName(gulp.currentTask);
    var isMainTask = taskName === mainBundleName;
    var runHot = isMainTask && !isIE && hot;

    var devPath = isDev ? 'http://' + devHost + ':' + hotPort + '/' : '/';
    var bsPath = isDev ? 'http://' + devHost + ':' + devPort + '/' : '/';

    if (runHot) {
      publicPath = (0, _lodash.isUndefined)(branch) ? devPath : assetPath;
    } else {
      publicPath = (0, _lodash.isUndefined)(branch) ? bsPath : assetPath;
    }

    var baseConfig = (0, _lodash.assign)({}, config, { isMainTask: isMainTask, publicPath: publicPath, app: app });
    var webpackConfig = (0, _makeWebpackConfig2.default)(baseConfig);
    var parentConfig = (0, _runParentFn2.default)(_arguments, { data: webpackConfig });
    var data = parentConfig.data;
    var fn = parentConfig.fn;


    var task = function task(done) {
      var compiler = (0, _webpack2.default)(data);

      function logger(err, stats) {
        if (err) {
          throw new gutil.PluginError({
            plugin: '[webpack]',
            message: err.message
          });
        }

        if (!isDev) {
          gutil.log(stats.toString());
        }
      }

      compiler.plugin('compile', function () {
        gutil.log('Webpack Bundling ' + taskName + ' bundle');
      });

      compiler.plugin('done', function (stats) {
        gutil.log('Webpack Bundled ' + taskName + ' bundle in ' + (stats.endTime - stats.startTime) + 'ms');

        if (stats.hasErrors() || stats.hasWarnings()) {
          var _stats$toJson = stats.toJson({ errorDetails: true });

          var errors = _stats$toJson.errors;
          var warnings = _stats$toJson.warnings;


          [errors, warnings].forEach(function (stat, i) {
            var type = i ? 'warning' : 'error';
            if (stat.length) {
              var _stat = _slicedToArray(stat, 1);

              var statStr = _stat[0];
              /*eslint-disable*/

              var _statStr$split = statStr.split('\n\n');

              var _statStr$split2 = _toArray(_statStr$split);

              var first = _statStr$split2[0];

              var rest = _statStr$split2.slice(1);
              /*eslint-enable*/


              if (rest.length) {
                gutil.log('[webpack: ' + taskName + ' bundle ' + type + ']\n', rest.join('\n\n'));
              } else {
                gutil.log('[webpack: ' + taskName + ' bundle ' + type + ']', stats.toString());
              }
            }
          });

          if (!isDev) {
            process.exit(1);
          }
        }

        //avoid multiple calls of gulp callback
        if ((0, _lodash.isFunction)(done)) {
          var gulpCb = done;
          done = null;

          gulpCb();
        }
      });

      if (isDev) {
        if (runHot) {
          (function () {
            var app = new _express2.default();
            var serverOptions = {
              contentBase: buildDir,
              quiet: true,
              noInfo: true,
              hot: true,
              inline: true,
              lazy: false,
              publicPath: publicPath,
              headers: { 'Access-Control-Allow-Origin': '*' },
              stats: { colors: true }
            };
            var hasRun = false;

            (0, _lodash.isFunction)(parentMiddleware) && parentMiddleware(config, app);

            app.use((0, _webpackDevMiddleware2.default)(compiler, serverOptions));
            app.use((0, _webpackHotMiddleware2.default)(compiler));

            compiler.plugin('done', function (stats) {
              if (!hasRun) {
                app.listen(hotPort, function (err) {
                  if (err) {
                    console.error(err);
                  } else {
                    console.info('==> 🚧  Webpack development server listening on port %s', hotPort);
                  }

                  hasRun = true;
                });
              }
            });
          })();
        } else {
          compiler.watch({
            aggregateTimeout: 300,
            poll: true
          }, logger);
        }
      } else {
        compiler.run(logger);
      }
    };

    return (0, _runCustomTask2.default)(task, fn, cb);
  };
};

var _lodash = require('lodash');

var _webpack = require('webpack');

var _webpack2 = _interopRequireDefault(_webpack);

var _makeWebpackConfig = require('./make-webpack-config');

var _makeWebpackConfig2 = _interopRequireDefault(_makeWebpackConfig);

var _runParentFn = require('../../utils/run-parent-fn');

var _runParentFn2 = _interopRequireDefault(_runParentFn);

var _runCustomTask = require('../../utils/run-custom-task');

var _runCustomTask2 = _interopRequireDefault(_runCustomTask);

var _express = require('express');

var _express2 = _interopRequireDefault(_express);

var _webpackDevMiddleware = require('webpack-dev-middleware');

var _webpackDevMiddleware2 = _interopRequireDefault(_webpackDevMiddleware);

var _webpackHotMiddleware = require('webpack-hot-middleware');

var _webpackHotMiddleware2 = _interopRequireDefault(_webpackHotMiddleware);

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

function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }

module.exports = exports['default'];