js-app-plugin-universal-webpack/build/index.js

'use strict';

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; };

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

/* eslint-disable global-require, no-console */
const fs = require('fs-extra');
const openBrowser = require('react-dev-utils/openBrowser');
const webpack = require('webpack');
const WebpackDevServer = require('webpack-dev-server');

const configurations = {
  client: {
    development: require('./config/client/development'),
    production: require('./config/client/production')
  },
  server: {
    development: require('./config/server/development'),
    production: require('./config/server/production')
  }
};

function createRunOnceCompiler(webpackConfig) {
  return new Promise((resolve, reject) => {
    try {
      webpack(webpackConfig, (err, stats) => {
        if (err || stats.hasErrors()) {
          return reject(err);
        }

        return resolve();
      });
    } catch (e) {
      reject(e);
    }
  });
}

const plugin = (env, runOnce = false, logger) => {
  let clientLogger;
  let serverLogger;
  const { env: envVariables, settings } = env.getConfiguration();
  let serverCompiler;
  let clientDevServer;

  return {
    build() {
      return _asyncToGenerator(function* () {
        clientLogger = logger.createGroup('client');
        serverLogger = logger.createGroup('server');
        const clientConfig = configurations.client[env.getName()](env, clientLogger);
        const serverConfig = configurations.server[env.getName()](env, serverLogger);

        fs.removeSync(settings.client.bundleDir);
        fs.removeSync(settings.server.bundleDir);

        const compilers = [createRunOnceCompiler(clientConfig), createRunOnceCompiler(serverConfig)];

        return yield Promise.all(compilers);
      })();
    },

    start() {
      return _asyncToGenerator(function* () {
        clientLogger = logger.createGroup('client');
        serverLogger = logger.createGroup('server');
        const clientConfig = configurations.client[env.getName()](env, clientLogger);
        const serverConfig = configurations.server[env.getName()](env, serverLogger);

        return new Promise(function (resolve, reject) {
          try {
            const clientCompiler = webpack(clientConfig);

            clientDevServer = new WebpackDevServer(clientCompiler, {
              clientLogLevel: 'none',
              contentBase: envVariables.PUBLIC_DIR,
              historyApiFallback: {
                disableDotRule: true
              },
              https: settings.client.protocol === 'https',
              host: 'localhost',
              hot: true,
              proxy: {
                '!(/__webpack_hmr|**/*.*)': `http://localhost:${ envVariables.SERVER_PORT }`
              },
              publicPath: '/',
              quiet: true,
              watchOptions: {
                ignored: /node_modules/
              }
            });

            clientDevServer.listen(envVariables.SERVER_PORT - 1, function (err) {
              if (err) {
                console.log(err);
                return reject(err);
              }

              return openBrowser(`${ settings.client.protocol || 'http' }://localhost:${ envVariables.SERVER_PORT - 1 }/`);
            });

            serverCompiler = webpack(_extends({}, serverConfig, {
              watchOptions: {
                ignored: /node_modules/
              }
            })).watch({}, function () {});
          } catch (e) {
            reject(e);
          }

          resolve();
        });
      })();
    },

    terminate() {
      return _asyncToGenerator(function* () {
        clientLogger.remove();
        serverLogger.remove();

        if (serverCompiler) {
          return Promise.all([new Promise(function (resolve) {
            return serverCompiler.close(resolve);
          }), new Promise(function (resolve) {
            return clientDevServer.close(resolve);
          })]);
        }

        return true;
      })();
    }
  };
};

module.exports = plugin;