build-boiler/gulp/tasks/webpack/loaders/index.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; };

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 (opts) {
  var environment = opts.environment;
  var sources = opts.sources;
  var toolsPlugin = opts.toolsPlugin;
  var utils = opts.utils;
  var quick = opts.quick;
  var isMainTask = opts.isMainTask;
  var webpackConfig = opts.webpackConfig;
  var DEBUG = opts.DEBUG;
  var SERVER = opts.SERVER;
  var TEST = opts.TEST;
  var baseBabelrc = sources.babelrc;
  var includePaths = sources.includePaths;
  var rootDir = sources.rootDir;
  var srcDir = sources.srcDir;
  var entry = sources.entry;
  var mainBundleName = sources.mainBundleName;
  var expose = webpackConfig.expose;
  var paths = webpackConfig.paths;
  var hot = webpackConfig.hot;
  var _webpackConfig$loader = webpackConfig.loaders;
  var loaderParentConfig = _webpackConfig$loader === undefined ? {} : _webpackConfig$loader;
  var _webpackConfig$babel = webpackConfig.babel;
  var babelParentConfig = _webpackConfig$babel === undefined ? {} : _webpackConfig$babel;
  var isDev = environment.isDev;
  var isIE = environment.isIE;
  var fileLoader = paths.fileLoader;
  var addbase = utils.addbase;
  var addroot = utils.addroot;

  var excludeRe = /^(.*?\/)?node_modules\/(?!@hfa\/).+\.jsx?$/;
  var babelQuery = {};
  var babelBaseConfig = _lodash2.default.omit(baseBabelrc, ['env']);
  var imageLoader = 'img?' + ['progressive=true', 'minimize'].join('&');
  var runHot = isMainTask && hot && !isIE;
  var sassParams = ['outputStyle=' + (DEBUG || quick ? 'expanded' : 'compressed')];
  var sassLoader = undefined,
      cssLoader = undefined,
      staticAssetsLoader = undefined;

  if (Array.isArray(includePaths)) {
    includePaths.reduce(function (list, fp) {
      list.push('includePaths[]=' + fp);
      return list;
    }, sassParams);
  } else if (_lodash2.default.isString(includePaths)) {
    sassParams.push('includePaths[]=' + includePaths);
  }

  sassParams.push('sourceMap', 'sourceMapContents=true');

  /**
   * Various parent config mutation functions
   */
  var omitPolyfill = babelParentConfig.omitPolyfill;
  var transform = babelParentConfig.transform;
  var parentBabelQuery = babelParentConfig.query;
  var parentBabelExclude = babelParentConfig.exclude;
  var parentBabelrc = babelParentConfig.babelrc;

  var callParentFn = (0, _callAndReturn2.default)(opts);

  var babelrc = callParentFn(parentBabelrc, baseBabelrc);

  if (DEBUG || TEST) {
    var babelEnvConfig = _lodash2.default.cloneDeep(babelrc.env.development);
    var plugins = undefined;

    if (TEST) {
      plugins = babelEnvConfig.plugins.filter(function (plugin) {
        return _lodash2.default.isString(plugin) && plugin !== 'transform-runtime';
      });
      _lodash2.default.assign(babelEnvConfig, { plugins: plugins });
    } else if (runHot) {
      plugins = babelEnvConfig.plugins.filter(function (plugin) {
        return plugin !== 'rewire';
      });
      _lodash2.default.assign(babelEnvConfig, { plugins: plugins });
    } else {
      plugins = babelEnvConfig.plugins.filter(function (plugin) {
        return _lodash2.default.isString(plugin) && plugin !== 'rewire';
      });
      _lodash2.default.assign(babelEnvConfig, { plugins: plugins });
    }

    _lodash2.default.assign(babelEnvConfig, { plugins: plugins });
    _lodash2.default.assign(babelQuery, babelBaseConfig, babelEnvConfig);

    if (isMainTask) {
      sassLoader = ['style-loader', 'css-loader?sourceMap&importLoaders=2', 'postcss-loader', 'sass-loader?' + sassParams.join('&')].join('!');
    } else {
      sassLoader = _extractTextWebpackPlugin2.default.extract('style-loader', ['css-loader?sourceMap&importLoaders=2', 'postcss-loader', 'sass-loader?' + sassParams.join('&')].join('!'));
    }

    cssLoader = ['style-loader', 'css-loader?sourceMap&importLoaders=1&modules&localIdentName=[name]__[local]___[hash:base64:5]', 'postcss-loader'].join('!');
  } else {
    var babelEnvConfig = babelrc.env.production;

    if (SERVER) {
      (function () {
        var omit = ['typecheck', 'rewire'];
        var plugins = babelEnvConfig.plugins.filter(function (plugin) {
          return !omit.includes(plugin);
        }).concat('add-module-exports');

        _lodash2.default.assign(babelEnvConfig, { plugins: plugins });

        cssLoader = [(0, _path.join)(__dirname, 'iso-tools-stats-loader'), 'postcss-loader'].join('!');
      })();
    } else {
      cssLoader = ['style-loader', 'css-loader?sourceMap&importLoaders=1&modules&localIdentName=[hash:base64:5]', 'postcss-loader'].join('!');
    }

    sassLoader = _extractTextWebpackPlugin2.default.extract('style-loader', ['css-loader?sourceMap&importLoaders=2', 'postcss-loader', 'sass-loader?' + sassParams.join('&')].join('!'));

    _lodash2.default.merge(babelQuery, babelBaseConfig, babelEnvConfig);
  }

  var preLoaders = [{
    test: /\.jsx?$/,
    exclude: /node_modules/,
    loader: 'eslint-loader'
  }];

  var transformPolly = ['transform-runtime', { polyfill: true }];
  var baseTransform = ['transform-runtime', { polyfill: false }];
  var babelPlugins = babelQuery.plugins;

  if (_lodash2.default.isArray(transform)) {
    babelPlugins.unshift(transform);
  } else if (transform) {
    babelPlugins.unshift(omitPolyfill ? baseTransform : transformPolly);
  }

  var babelKeys = ['plugins', 'presets'];
  var babelRootQuery = Object.keys(babelQuery).reduce(function (acc, key) {
    var val = babelQuery[key];

    //hack to get babel plugins to work from nested directory
    //https://github.com/babel/babel-loader/issues/166
    if (babelKeys.includes(key)) {
      acc[key] = val.map(function (name) {
        var basename = undefined;

        if (Array.isArray(name)) {
          var _name = _slicedToArray(name, 2);

          var pluginName = _name[0];
          var data = _name[1];

          var modName = 'babel-plugin-' + pluginName;
          var modPath = undefined;

          try {
            modPath = require.resolve(modName);
          } catch (err) {
            modPath = addroot('node_modules', modName);
          }

          var _ref = data || {};

          var transforms = _ref.transforms;


          if (transforms) {
            var recursedData = transforms.reduce(function (acc, pluginData) {
              var transform = pluginData.transform;

              var pluginPath = undefined;

              try {
                pluginPath = require.resolve(transform);
              } catch (err) {
                pluginPath = addroot('node_modules', transform);
              }

              var transformData = Object.assign({}, pluginData, { transform: pluginPath });

              acc.transforms.push(transformData);

              return acc;
            }, { transforms: [] });

            basename = [modPath, recursedData];
          } else {
            basename = data ? [modPath, data] : [modPath];
          }
        } else {
          switch (key) {
            case 'presets':
              basename = 'babel-preset-' + name;
              break;
            case 'plugins':
              basename = 'babel-plugin-' + name;
              break;
          }

          try {
            basename = require.resolve(basename);
          } catch (err) {
            basename = addroot('node_modules', 'babel-plugin-' + name);
          }
        }

        return basename;
      });
    } else {
      acc[key] = val;
    }

    return acc;
  }, {});

  if (SERVER) {
    staticAssetsLoader = (0, _path.join)(__dirname, 'iso-tools-stats-loader');
  } else if (isDev) {
    staticAssetsLoader = fileLoader;
  } else {
    staticAssetsLoader = [fileLoader, imageLoader].join('!');
  }

  var finalBabelQuery = callParentFn(parentBabelQuery, babelRootQuery);

  var loaders = [{
    test: /\.jsx?$/,
    exclude: function exclude(fp) {
      var parentEx = callParentFn(parentBabelExclude, fp);
      var ex = false;

      if (_lodash2.default.isBoolean(parentEx)) {
        ex = parentEx;
      } else {
        if (fp.indexOf(rootDir) !== -1) {
          var root = fp.replace(rootDir, '');
          ex = excludeRe.test(root);
        } else {
          ex = ex = excludeRe.test(fp);
        }
      }

      return ex;
    },

    loader: 'babel',
    query: finalBabelQuery
  }, {
    test: toolsPlugin.regular_expression('images'),
    loader: staticAssetsLoader
  }, {
    test: /\.(ico|ttf|eot|woff(2)?)(\?[a-z0-9]+)?$/,
    loader: fileLoader
  }, {
    test: /\.json$/,
    loader: 'json'
  }, {
    test: /\.css$/,
    loader: cssLoader
  }, {
    test: /\.scss$/,
    loader: sassLoader
  }];

  if (SERVER) {
    loaders.unshift({
      test: /\.jsx?$/,
      exclude: excludeRe,
      loader: (0, _path.join)(__dirname, 'mocks-loader')
    });
  }

  var postLoaders = [];

  if (expose && isMainTask) {
    var keys = Object.keys(expose);

    keys.forEach(function (modName) {
      var exposeName = expose[modName];
      var method = 'push';
      var testPath = undefined;

      if (modName === 'app') {
        var _entry$mainBundleName = _slicedToArray(entry[mainBundleName], 1);

        var bundleName = _entry$mainBundleName[0];

        testPath = addbase(srcDir, bundleName);
        method = 'unshift';
      } else {
        testPath = require.resolve(modName);
      }

      postLoaders[method]({
        test: testPath,
        loader: 'expose?' + exposeName
      });
    });
  }

  return _extends({}, callParentFn(loaderParentConfig, { preLoaders: preLoaders, loaders: loaders, postLoaders: postLoaders }), {
    babelQuery: finalBabelQuery
  });
};

var _path = require('path');

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _extractTextWebpackPlugin = require('extract-text-webpack-plugin');

var _extractTextWebpackPlugin2 = _interopRequireDefault(_extractTextWebpackPlugin);

var _callAndReturn = require('../../../utils/call-and-return');

var _callAndReturn2 = _interopRequireDefault(_callAndReturn);

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

module.exports = exports['default'];