react-middleware/lib/webpack-builder.js

Connect middleware for serving React components from a standard folder structure.

'use strict';

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

var _ramda = require('ramda');

var _ramda2 = _interopRequireDefault(_ramda);

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _webpack = require('webpack');

var _webpack2 = _interopRequireDefault(_webpack);

var _fsExtra = require('fs-extra');

var _fsExtra2 = _interopRequireDefault(_fsExtra);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _paths = require('./paths');

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

var BUILD_PATH = exports.BUILD_PATH = _path2.default.resolve('./.build/webpack');
var NODE_MODULES_PATH = _path2.default.resolve('./node_modules');
var IS_PRODUCTION = process.env.NODE_ENV === 'production';

var modulePath = function modulePath(moduleName) {
  return (0, _paths.closestModulePath)(_path2.default.resolve('.'), moduleName);
};

var SETTINGS = {
  resolveLoader: { fallback: NODE_MODULES_PATH },
  resolve: {
    fallback: NODE_MODULES_PATH,
    extensions: ['', '.js', '.jsx', 'json'],
    alias: {
      react: modulePath('react'),
      ramda: modulePath('ramda')
    }
  },
  module: {
    loaders: [
    // ES6/JSX.
    { test: /\.js$/, exclude: /(node_modules)/, loader: 'babel' }, { test: /\.jsx$/, exclude: /(node_modules)/, loader: 'babel' }, { test: /\.json$/, loader: 'json' }]
  }
};

var getSettings = function getSettings(entry, output) {
  var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];

  var config = _ramda2.default.merge(_ramda2.default.clone(SETTINGS), {
    entry: entry,
    output: {
      filename: _path2.default.basename(output),
      path: _path2.default.dirname(output)
    }
  });
  if (options.minify) {
    config.plugins = [new _webpack2.default.optimize.UglifyJsPlugin({ minimize: true })];
  }
  if (options.loaders) {
    config.module.loaders = options.loaders;
  }
  return config;
};

var shortenError = function shortenError(error) {
  if (error.name === 'ModuleBuildError') {
    var index = error.message.indexOf('    at ');
    if (index > -1) {
      error.message = error.message.substr(0, index);
    }
  }
};

var compile = function compile(entryPath, outputPath, loaders) {
  var minify = IS_PRODUCTION;
  var config = getSettings(entryPath, outputPath, { minify: minify, loaders: loaders });
  return new _bluebird2.default(function (resolve, reject) {
    (0, _webpack2.default)(config, function (err, result) {
      if (err) {
        reject({ errors: [err] });
      } else {
        var errors = result.compilation.errors;
        if (errors.length > 0) {
          errors.forEach(function (error) {
            return shortenError(error);
          });
          reject({ errors: errors });
        } else {
          var elapsed = result.endTime - result.startTime;
          var stats = _fsExtra2.default.lstatSync(outputPath);
          resolve({ elapsed: elapsed, fileSize: stats.size });
        }
      }
    });
  });
};

/**
 * Builder API.
 * @param {Object} settings:
 *            - paths:          {Object} of paths to known folders.
 *            - routes:         {Object} of routes.
 *            - loaders:        {Array} of webpack loaders to use.
 *                              Default loaders are replaced with this array.
 *
 */

exports.default = function () {
  var settings = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  var paths = settings.paths;
  var routes = settings.routes;

  // Build the list of paths to compile.

  var items = [];
  var add = function add(entry, outputFile) {
    items.push({
      entry: entry,
      output: BUILD_PATH + '/' + outputFile
    });
  };
  add(paths.scripts + '/index.js', 'base.js');
  _ramda2.default.values(routes).forEach(function (item) {
    var entry = paths.pages + '/' + item.page + '/' + (item.entry || 'entry.js');
    if (_fsExtra2.default.existsSync(entry)) {
      add(entry, 'pages/' + item.page + '.js');
    }
  });

  return new _bluebird2.default(function (resolve, reject) {
    // Run each item through the webpack compiler.
    var response = { files: [] };
    var compileItem = function compileItem(index) {
      if (index < items.length) {
        (function () {
          var item = items[index];
          if (_fsExtra2.default.existsSync(item.entry)) {
            compile(item.entry, item.output, settings.loaders).then(function (result) {
              response.files.push({
                path: item.entry.replace(paths.base, ''),
                elapsed: result.elapsed,
                fileSize: result.fileSize
              });
              compileItem(index + 1); // <== RECURSION.
            }).catch(function (err) {
              return reject(err);
            });
          }
        })();
      } else {
        // Complete.
        var sumElapsed = function sumElapsed(result, item) {
          return result + item.elapsed;
        };
        response.elapsed = _ramda2.default.reduce(sumElapsed, 0, response.files);
        resolve(response);
      }
    };
    compileItem(0);
  });
};
//# sourceMappingURL=webpack-builder.js.map