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

'use strict';

var main = function () {
  var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee8() {
    var _this = this;

    var collect = function () {
      var _ref5 = _asyncToGenerator(regeneratorRuntime.mark(function _callee5(include, exclude) {
        var collection, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, pattern, files;

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

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

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

              case 10:
                files = _context5.sent;

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

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

              case 15:
                _context5.next = 21;
                break;

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

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

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

              case 24:
                _context5.prev = 24;

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

                throw _iteratorError;

              case 27:
                return _context5.finish(24);

              case 28:
                return _context5.finish(21);

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

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

      return function collect(_x5, _x6) {
        return _ref5.apply(this, arguments);
      };
    }();

    var execute = function () {
      var _ref6 = _asyncToGenerator(regeneratorRuntime.mark(function _callee6(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 _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                _context6.next = 2;
                return all(pipeline.apply(undefined, input));

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

              case 5:
                return _context6.abrupt('return', result);

              case 6:
              case 'end':
                return _context6.stop();
            }
          }
        }, _callee6, this);
      }));

      return function execute(_x7, _x8, _x9) {
        return _ref6.apply(this, arguments);
      };
    }();

    var status = function () {
      var _ref7 = _asyncToGenerator(regeneratorRuntime.mark(function _callee7(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 _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _loop, _iterator2, _step2;

        return regeneratorRuntime.wrap(function _callee7$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                _iteratorNormalCompletion2 = true;
                _didIteratorError2 = false;
                _iteratorError2 = undefined;
                _context8.prev = 3;
                _loop = regeneratorRuntime.mark(function _loop() {
                  var result, _ref8, input, messages, files, error;

                  return regeneratorRuntime.wrap(function _loop$(_context7) {
                    while (1) {
                      switch (_context7.prev = _context7.next) {
                        case 0:
                          result = _step2.value;
                          _context7.next = 3;
                          return result;

                        case 3:
                          _ref8 = _context7.sent;
                          input = _ref8.input;
                          messages = _ref8.messages;
                          files = _ref8.files;
                          error = _ref8.error;


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

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

                        case 10:
                        case 'end':
                          return _context7.stop();
                      }
                    }
                  }, _loop, _this2);
                });
                _iterator2 = results[Symbol.iterator]();

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

                return _context8.delegateYield(_loop(), 't0', 8);

              case 8:
                _iteratorNormalCompletion2 = true;
                _context8.next = 6;
                break;

              case 11:
                _context8.next = 17;
                break;

              case 13:
                _context8.prev = 13;
                _context8.t1 = _context8['catch'](3);
                _didIteratorError2 = true;
                _iteratorError2 = _context8.t1;

              case 17:
                _context8.prev = 17;
                _context8.prev = 18;

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

              case 20:
                _context8.prev = 20;

                if (!_didIteratorError2) {
                  _context8.next = 23;
                  break;
                }

                throw _iteratorError2;

              case 23:
                return _context8.finish(20);

              case 24:
                return _context8.finish(17);

              case 25:
              case 'end':
                return _context8.stop();
            }
          }
        }, _callee7, this, [[3, 13, 17, 25], [18,, 20, 24]]);
      }));

      return function status(_x10, _x11) {
        return _ref7.apply(this, arguments);
      };
    }();

    var pkg, opts, console, pipeline, build, interactive;
    return regeneratorRuntime.wrap(function _callee8$(_context9) {
      while (1) {
        switch (_context9.prev = _context9.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;
            };

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

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

          case 6:
            opts = _context9.sent;
            console = (0, _stdio2.default)({ debug: !!process.env.DEBUG, format: opts.log });


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

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

            _context9.next = 14;
            return (0, _performance.timed)(keys(pipeline).reduce(function () {
              var _ref2 = _asyncToGenerator(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;
                        return _context.abrupt('return', result);

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

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

          case 14:
            build = _context9.sent;


            console.debug('Build took ' + build.duration.ms + ' ms');

            if (!opts.interactive) {
              _context9.next = 21;
              break;
            }

            keys(pipeline).forEach(function (type) {
              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', function () {
                var _ref3 = _asyncToGenerator(regeneratorRuntime.mark(function _callee2(file) {
                  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:
                          return _context2.abrupt('return', _context2.sent);

                        case 3:
                        case 'end':
                          return _context2.stop();
                      }
                    }
                  }, _callee2, _this);
                }));

                return function (_x3) {
                  return _ref3.apply(this, arguments);
                };
              }()).on('change', function () {
                var _ref4 = _asyncToGenerator(regeneratorRuntime.mark(function _callee3(file) {
                  return regeneratorRuntime.wrap(function _callee3$(_context3) {
                    while (1) {
                      switch (_context3.prev = _context3.next) {
                        case 0:
                          _context3.next = 2;
                          return execute(type, pipeline[type], file);

                        case 2:
                          return _context3.abrupt('return', _context3.sent);

                        case 3:
                        case 'end':
                          return _context3.stop();
                      }
                    }
                  }, _callee3, _this);
                }));

                return function (_x4) {
                  return _ref4.apply(this, arguments);
                };
              }());
            });
            console.info('Watching source files for changes...');
            _context9.next = 23;
            break;

          case 21:
            if (!opts.optimize) {
              _context9.next = 23;
              break;
            }

            return _context9.delegateYield(regeneratorRuntime.mark(function _callee4() {
              var extension, winslash, filename, contents, _filename, _contents;

              return regeneratorRuntime.wrap(function _callee4$(_context4) {
                while (1) {
                  switch (_context4.prev = _context4.next) {
                    case 0:
                      console.debug('Writing optimised-modules.json');
                      extension = /^([^\.]+).*$/;
                      winslash = /\\/g;
                      _context4.next = 5;
                      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 5:
                      if (!build.result.css.length) {
                        _context4.next = 13;
                        break;
                      }

                      console.debug('Writing ' + opts.out + '.css');
                      filename = pkg.resolve(opts.out + '.css');
                      _context4.next = 10;
                      return (0, _css4.default)(pkg, opts)(build.result.css);

                    case 10:
                      contents = _context4.sent;
                      _context4.next = 13;
                      return (0, _file.put)(filename, contents);

                    case 13:
                      if (!build.result.js.length) {
                        _context4.next = 21;
                        break;
                      }

                      console.debug('Writing ' + opts.out + '.js');
                      _filename = pkg.resolve(opts.out + '.js');
                      _context4.next = 18;
                      return (0, _javascript4.default)(pkg, opts)(build.result.js);

                    case 18:
                      _contents = _context4.sent;
                      _context4.next = 21;
                      return (0, _file.put)(_filename, _contents);

                    case 21:
                    case 'end':
                      return _context4.stop();
                  }
                }
              }, _callee4, _this);
            })(), 't0', 23);

          case 23:
          case 'end':
            return _context9.stop();
        }
      }
    }, _callee8, this);
  }));

  return function main() {
    return _ref.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) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

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

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