@zambezi/ez-build/lib/main.js

'use strict';

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

var main = function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6() {
    var _this = this;

    var collect = function () {
      var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(include, exclude) {
        var collection, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, pattern, files;

        return regeneratorRuntime.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                collection = [];
                _iteratorNormalCompletion = true;
                _didIteratorError = false;
                _iteratorError = undefined;
                _context3.prev = 4;
                _iterator = include[Symbol.iterator]();

              case 6:
                if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
                  _context3.next = 15;
                  break;
                }

                pattern = _step.value;
                _context3.next = 10;
                return (0, _file.find)(`${opts.src}/${pattern}`, { nodir: true, ignore: exclude, cwd: pkg.root });

              case 10:
                files = _context3.sent;

                collection = [].concat(_toConsumableArray(collection), _toConsumableArray(files));

              case 12:
                _iteratorNormalCompletion = true;
                _context3.next = 6;
                break;

              case 15:
                _context3.next = 21;
                break;

              case 17:
                _context3.prev = 17;
                _context3.t0 = _context3['catch'](4);
                _didIteratorError = true;
                _iteratorError = _context3.t0;

              case 21:
                _context3.prev = 21;
                _context3.prev = 22;

                if (!_iteratorNormalCompletion && _iterator.return) {
                  _iterator.return();
                }

              case 24:
                _context3.prev = 24;

                if (!_didIteratorError) {
                  _context3.next = 27;
                  break;
                }

                throw _iteratorError;

              case 27:
                return _context3.finish(24);

              case 28:
                return _context3.finish(21);

              case 29:
                return _context3.abrupt('return', collection);

              case 30:
              case 'end':
                return _context3.stop();
            }
          }
        }, _callee3, this, [[4, 17, 21, 29], [22,, 24, 28]]);
      }));

      return function collect(_x4, _x5) {
        return _ref4.apply(this, arguments);
      };
    }();

    var execute = function () {
      var _ref5 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(type, pipeline) {
        for (var _len = arguments.length, input = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
          input[_key - 2] = arguments[_key];
        }

        var result;
        return regeneratorRuntime.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                _context4.next = 2;
                return all(pipeline.apply(undefined, _toConsumableArray(input)));

              case 2:
                result = _context4.sent;
                return _context4.abrupt('return', result);

              case 4:
              case 'end':
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      return function execute(_x6, _x7) {
        return _ref5.apply(this, arguments);
      };
    }();

    var status = function () {
      var _ref6 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(type) {
        var _this2 = this;

        for (var _len2 = arguments.length, results = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
          results[_key2 - 1] = arguments[_key2];
        }

        var _loop, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, result;

        return regeneratorRuntime.wrap(function _callee5$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                _loop = /*#__PURE__*/regeneratorRuntime.mark(function _loop(result) {
                  var _ref7, input, messages, files, error;

                  return regeneratorRuntime.wrap(function _loop$(_context5) {
                    while (1) {
                      switch (_context5.prev = _context5.next) {
                        case 0:
                          _context5.next = 2;
                          return result;

                        case 2:
                          _ref7 = _context5.sent;
                          input = _ref7.input;
                          messages = _ref7.messages;
                          files = _ref7.files;
                          error = _ref7.error;


                          if (messages) {
                            [].concat(_toConsumableArray(messages)).forEach(function (message) {
                              console.warn((0, _ansicolors.yellow)(`${type} – ${input}: ${message}`));
                            });
                          }

                          if (error) {
                            console.error((0, _ansicolors.red)(`${type} – ${error.message}\n${error.codeFrame || error.stack}`));
                          } else {
                            console.log(`${type} – ${input} -> ${files}`);
                          }

                        case 9:
                        case 'end':
                          return _context5.stop();
                      }
                    }
                  }, _loop, _this2);
                });
                _iteratorNormalCompletion2 = true;
                _didIteratorError2 = false;
                _iteratorError2 = undefined;
                _context6.prev = 4;
                _iterator2 = results[Symbol.iterator]();

              case 6:
                if (_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done) {
                  _context6.next = 12;
                  break;
                }

                result = _step2.value;
                return _context6.delegateYield(_loop(result), 't0', 9);

              case 9:
                _iteratorNormalCompletion2 = true;
                _context6.next = 6;
                break;

              case 12:
                _context6.next = 18;
                break;

              case 14:
                _context6.prev = 14;
                _context6.t1 = _context6['catch'](4);
                _didIteratorError2 = true;
                _iteratorError2 = _context6.t1;

              case 18:
                _context6.prev = 18;
                _context6.prev = 19;

                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                  _iterator2.return();
                }

              case 21:
                _context6.prev = 21;

                if (!_didIteratorError2) {
                  _context6.next = 24;
                  break;
                }

                throw _iteratorError2;

              case 24:
                return _context6.finish(21);

              case 25:
                return _context6.finish(18);

              case 26:
              case 'end':
                return _context6.stop();
            }
          }
        }, _callee5, this, [[4, 14, 18, 26], [19,, 21, 25]]);
      }));

      return function status(_x8) {
        return _ref6.apply(this, arguments);
      };
    }();

    var pkg, opts, console, pipeline, build, extension, winslash, filename, contents, _filename, _contents, interactive;

    return regeneratorRuntime.wrap(function _callee6$(_context7) {
      while (1) {
        switch (_context7.prev = _context7.next) {
          case 0:
            interactive = function interactive(include, exclude) {
              var watcher = (0, _chokidar.watch)(include.reduce(function (files, pattern) {
                return files.concat(`${opts.src}/${pattern}`);
              }, []), { ignored: exclude, cwd: pkg.root, ignoreInitial: true });

              return watcher;
            };

            _context7.next = 3;
            return (0, _pkg.read)(process.cwd());

          case 3:
            pkg = _context7.sent;
            _context7.next = 6;
            return (0, _opts2.default)(pkg, process.argv);

          case 6:
            opts = _context7.sent;
            console = (0, _stdio2.default)({ debug: !!process.env.DEBUG, format: opts.log });
            _context7.next = 10;
            return babelrcWarning(pkg, console);

          case 10:
            opts.babelrc = _context7.sent;


            console.debug('Options:');
            keys(opts).forEach(function (name) {
              return console.debug(`- ${name}: ${JSON.stringify(opts[name])}`);
            });

            if (process.env.NODE_ENV === undefined) {
              process.env.NODE_ENV = opts.production ? 'production' : 'development';
            }

            pipeline = void 0;


            try {
              pipeline = { js: (0, _pipeline2.default)(pkg, opts, (0, _javascript2.default)(pkg, opts)),
                css: (0, _pipeline2.default)(pkg, opts, (0, _css2.default)(pkg, opts))
              };

              if (opts.copy) {
                pipeline['copy-files'] = (0, _pipeline2.default)(pkg, opts, (0, _copyFiles2.default)(pkg, opts));
              }
            } catch (e) {
              console.error((0, _ansicolors.red)(`Failed to start compiler: ${e.message}`));
              process.exit(1);
            }

            _context7.next = 18;
            return (0, _performance.timed)(keys(pipeline).reduce(function () {
              var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(result, type) {
                var input;
                return regeneratorRuntime.wrap(function _callee$(_context) {
                  while (1) {
                    switch (_context.prev = _context.next) {
                      case 0:
                        _context.next = 2;
                        return result;

                      case 2:
                        result = _context.sent;
                        _context.next = 5;
                        return collect(opts.include[type], opts.exclude[type]);

                      case 5:
                        input = _context.sent;
                        _context.next = 8;
                        return execute.apply(undefined, [type, pipeline[type]].concat(_toConsumableArray(input)));

                      case 8:
                        result[type] = _context.sent;

                        result[type].errors = result[type].filter(function (result) {
                          return result.error;
                        });

                        if (!(!opts.interactive || process.stdout.isTTY)) {
                          _context.next = 13;
                          break;
                        }

                        _context.next = 13;
                        return status.apply(undefined, [type].concat(_toConsumableArray(result[type])));

                      case 13:
                        return _context.abrupt('return', result);

                      case 14:
                      case 'end':
                        return _context.stop();
                    }
                  }
                }, _callee, _this);
              }));

              return function (_x, _x2) {
                return _ref2.apply(this, arguments);
              };
            }(), {}));

          case 18:
            build = _context7.sent;


            console.debug(`Build took ${build.duration.ms} ms`);

            if (!opts.interactive) {
              _context7.next = 25;
              break;
            }

            keys(pipeline).forEach(function (type) {
              var build = function () {
                var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(file) {
                  var result;
                  return regeneratorRuntime.wrap(function _callee2$(_context2) {
                    while (1) {
                      switch (_context2.prev = _context2.next) {
                        case 0:
                          _context2.next = 2;
                          return execute(type, pipeline[type], file);

                        case 2:
                          result = _context2.sent;
                          _context2.next = 5;
                          return status.apply(undefined, [type].concat(_toConsumableArray(result)));

                        case 5:
                        case 'end':
                          return _context2.stop();
                      }
                    }
                  }, _callee2, this);
                }));

                return function build(_x3) {
                  return _ref3.apply(this, arguments);
                };
              }();

              console.debug(`Watching ${type} pipeline:`);
              console.debug(`- included: ${opts.include[type]}`);
              console.debug(`- excluded: ${opts.exclude[type]}`);
              interactive(opts.include[type], opts.exclude[type]).on('add', build).on('change', build);
            });
            console.info('Watching source files for changes...');
            _context7.next = 52;
            break;

          case 25:
            if (!keys(build.result).some(function (type) {
              return build.result[type].errors.length;
            })) {
              _context7.next = 30;
              break;
            }

            console.info('\nBuild failed to due unrecoverable errors.');
            process.exit(1);
            _context7.next = 52;
            break;

          case 30:
            if (!opts.optimize) {
              _context7.next = 52;
              break;
            }

            console.debug('Writing optimised-modules.json');
            extension = /^([^\.]+).*$/;
            winslash = /\\/g;
            _context7.next = 36;
            return (0, _file.put)(pkg.resolve('optimised-modules.json'), JSON.stringify(new Set(keys(build.result).reduce(function (files, type) {
              var pipe = build.result[type];
              return pipe.reduce(function (files, result) {
                if (result.files) {
                  return [].concat(_toConsumableArray(files), _toConsumableArray(result.files.map(function (file) {
                    var name = file.replace(extension, '$1').replace(winslash, '/');
                    return `${pkg.name}/${name}`;
                  })));
                } else {
                  return files;
                }
              }, files);
            }, [])), null, 2));

          case 36:
            if (!build.result.css.length) {
              _context7.next = 44;
              break;
            }

            console.debug(`Writing ${opts.out}.css`);
            filename = pkg.resolve(`${opts.out}.css`);
            _context7.next = 41;
            return (0, _css4.default)(pkg, opts)(build.result.css);

          case 41:
            contents = _context7.sent;
            _context7.next = 44;
            return (0, _file.put)(filename, contents);

          case 44:
            if (!build.result.js.length) {
              _context7.next = 52;
              break;
            }

            console.debug(`Writing ${opts.out}.js`);
            _filename = pkg.resolve(`${opts.out}.js`);
            _context7.next = 49;
            return (0, _javascript4.default)(pkg, opts)(build.result.js);

          case 49:
            _contents = _context7.sent;
            _context7.next = 52;
            return (0, _file.put)(_filename, _contents);

          case 52:
          case 'end':
            return _context7.stop();
        }
      }
    }, _callee6, this);
  }));

  return function main() {
    return _ref.apply(this, arguments);
  };
}();

var babelrcWarning = function () {
  var _ref8 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee7(pkg, console) {
    var babelrc, _messages;

    return regeneratorRuntime.wrap(function _callee7$(_context8) {
      while (1) {
        switch (_context8.prev = _context8.next) {
          case 0:
            babelrc = void 0;
            _context8.prev = 1;
            _context8.t0 = JSON;
            _context8.next = 5;
            return (0, _file.slurp)(pkg.resolve('.babelrc'), 'utf8');

          case 5:
            _context8.t1 = _context8.sent;
            babelrc = _context8.t0.parse.call(_context8.t0, _context8.t1);
            _context8.next = 12;
            break;

          case 9:
            _context8.prev = 9;
            _context8.t2 = _context8['catch'](1);

            babelrc = pkg.babel;

          case 12:

            if (babelrc) {
              _messages = [];
              (babelrc.presets || []).forEach(function (preset) {
                var _concat = [].concat(preset),
                    _concat2 = _slicedToArray(_concat, 1),
                    name = _concat2[0];

                if (name === 'es2015' || name === 'es2016') {
                  _messages.push(`${name} support is always enabled`);
                } else if (name === 'es2017') {
                  _messages.push('To enable es2017 support, use: --flags es2017');
                } else if (name === 'react') {
                  _messages.push('To enable react support, use: --flags react');
                } else {
                  _messages.push(`Unsupported preset: ${name}`);
                }
              });(babelrc.plugins || []).forEach(function (plugin) {
                var _concat3 = [].concat(plugin),
                    _concat4 = _slicedToArray(_concat3, 1),
                    name = _concat4[0];

                if (/^transform-es2015-modules-(umd|amd|ecmascript|commonjs|systemjs)$/.test(name)) {
                  var format = name.slice('transform-es2015-modules-'.length);
                  _messages.push(`To enable ${format} modules, use: --flags modules:${format}`);
                } else {
                  _messages.push(`Unsupported plugin: ${name}`);
                }
              });

              if (babelrc.env) {
                _messages.push(`babel.env: NODE_ENV is respected by ez-build`);
              }

              console.warn((0, _ansicolors.red)('WARNING: ez-build is discontinuing support for .babelrc'), (0, _ansicolors.yellow)(`

Currently ez-build still loads .babelrc files, but this support is
going away before v1.0.0. Please make sure to migrate any relevant
configuration to use flags instead.

Not sure how to migrate? Please open an issue:

https://github.com/zambezi/ez-build/issues/new
${_messages.length ? `
Comments on the detected babel configuration:

- ${_messages.join('\n- ')}
` : ''}
`));
            }

            return _context8.abrupt('return', !!babelrc);

          case 14:
          case 'end':
            return _context8.stop();
        }
      }
    }, _callee7, this, [[1, 9]]);
  }));

  return function babelrcWarning(_x9, _x10) {
    return _ref8.apply(this, arguments);
  };
}();

var _pkg = require('./util/pkg');

var _file = require('./util/file');

var _stdio = require('./util/stdio');

var _stdio2 = _interopRequireDefault(_stdio);

var _javascript = require('./builder/javascript');

var _javascript2 = _interopRequireDefault(_javascript);

var _css = require('./builder/css');

var _css2 = _interopRequireDefault(_css);

var _copyFiles = require('./builder/copy-files');

var _copyFiles2 = _interopRequireDefault(_copyFiles);

var _pipeline = require('./pipeline');

var _pipeline2 = _interopRequireDefault(_pipeline);

var _javascript3 = require('./postbuild/javascript');

var _javascript4 = _interopRequireDefault(_javascript3);

var _css3 = require('./postbuild/css');

var _css4 = _interopRequireDefault(_css3);

var _ansicolors = require('ansicolors');

var _chokidar = require('chokidar');

var _performance = require('./util/performance');

require('./util/cli');

var _opts = require('./cli/opts');

var _opts2 = _interopRequireDefault(_opts);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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); } }

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

var keys = Object.keys;
var all = Promise.all.bind(Promise);

main();
//# sourceMappingURL=main.js.map