@elodin/cli/es/command.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = _default;

require("@babel/polyfill");

var _defaults = _interopRequireDefault(require("lodash/defaults"));

var _outputFileSync = _interopRequireDefault(require("output-file-sync"));

var _mkdirp = require("mkdirp");

var _perf_hooks = require("perf_hooks");

var _rimraf = _interopRequireDefault(require("rimraf"));

var _slash = _interopRequireDefault(require("slash"));

var _path = _interopRequireDefault(require("path"));

var _chalk = _interopRequireDefault(require("chalk"));

var _glob = _interopRequireDefault(require("glob"));

var _fs = _interopRequireDefault(require("fs"));

var util = _interopRequireWildcard(require("./util"));

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj["default"] = obj; return newObj; } }

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

function _templateObject5() {
  var data = _taggedTemplateLiteral([", {red ", " error", "}"]);

  _templateObject5 = function _templateObject5() {
    return data;
  };

  return data;
}

function _templateObject4() {
  var data = _taggedTemplateLiteral(["{cyan >>>> Finish compiling (", " file", "", ")} ", " mseconds"]);

  _templateObject4 = function _templateObject4() {
    return data;
  };

  return data;
}

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _templateObject3() {
  var data = _taggedTemplateLiteral(["{cyan >>>> Start compiling}"]);

  _templateObject3 = function _templateObject3() {
    return data;
  };

  return data;
}

function _templateObject2() {
  var data = _taggedTemplateLiteral(["{bold.red Unable to find a generator in your elodin configuration.}\n   \n{red A generator is required to be able to compile elodin files.\nFor further information check out {underline https://elodin.dev/docs/setup/configuration}.}"]);

  _templateObject2 = function _templateObject2() {
    return data;
  };

  return data;
}

function _templateObject() {
  var data = _taggedTemplateLiteral(["{bold.red Unable to locate the elodin config file at ", ".}\n   \n{red A valid elodin configuration must be passed.\nStart by creating a {bold elodin.config.js} file.\nFor further information check out {underline https://elodin.dev/docs/setup/getting-started}.}"]);

  _templateObject = function _templateObject() {
    return data;
  };

  return data;
}

function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

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

function _ref() {
  _ref = _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee4(_ref2) {
    var cliOptions, elodinOptions, config, configPath, filenames, didClean, ignorePattern, walk, _walk, files, _files2;

    return regeneratorRuntime.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            _files2 = function _ref7() {
              _files2 = _asyncToGenerator(
              /*#__PURE__*/
              regeneratorRuntime.mark(function _callee3(filenames) {
                var chokidar;
                return regeneratorRuntime.wrap(function _callee3$(_context3) {
                  while (1) {
                    switch (_context3.prev = _context3.next) {
                      case 0:
                        if (cliOptions.skipInitialBuild) {
                          _context3.next = 3;
                          break;
                        }

                        _context3.next = 3;
                        return walk(filenames);

                      case 3:
                        if (cliOptions.watch) {
                          chokidar = util.requireChokidar();
                          chokidar.watch(filenames, {
                            persistent: true,
                            ignoreInitial: true,
                            awaitWriteFinish: {
                              stabilityThreshold: 50,
                              pollInterval: 10
                            }
                          }).on('all', function (type, filename) {
                            if (!util.isCompilableExtension(filename)) {
                              return;
                            }

                            if (type === 'add' || type === 'change') {
                              walk(filenames)["catch"](function (err) {
                                console.error(err);
                              });
                            }
                          });
                        }

                      case 4:
                      case "end":
                        return _context3.stop();
                    }
                  }
                }, _callee3);
              }));
              return _files2.apply(this, arguments);
            };

            files = function _ref6(_x3) {
              return _files2.apply(this, arguments);
            };

            _walk = function _ref5() {
              _walk = _asyncToGenerator(
              /*#__PURE__*/
              regeneratorRuntime.mark(function _callee2(filenames) {
                var _filenames, start, files, compileConfig, results, end, fail;

                return regeneratorRuntime.wrap(function _callee2$(_context2) {
                  while (1) {
                    switch (_context2.prev = _context2.next) {
                      case 0:
                        console.log((0, _chalk["default"])(_templateObject3()));
                        _filenames = [];
                        start = _perf_hooks.performance.now();
                        filenames.forEach(function (filename) {
                          if (!_fs["default"].existsSync(filename)) return;

                          var stat = _fs["default"].statSync(filename);

                          if (stat.isDirectory()) {
                            var dirname = filename;
                            util.readdirForCompilable(filename).forEach(function (filename) {
                              _filenames.push(_path["default"].join(dirname, filename));
                            });
                          } else {
                            _filenames.push(filename);
                          }
                        });
                        files = 0;
                        compileConfig = _objectSpread({}, config, {
                          errors: cliOptions.watch ? 'log' : 'throw',
                          errorCount: 0
                        });
                        _context2.next = 8;
                        return Promise.all(_filenames.map(
                        /*#__PURE__*/
                        function () {
                          var _ref3 = _asyncToGenerator(
                          /*#__PURE__*/
                          regeneratorRuntime.mark(function _callee(filename) {
                            var sourceFilename, didCompile;
                            return regeneratorRuntime.wrap(function _callee$(_context) {
                              while (1) {
                                switch (_context.prev = _context.next) {
                                  case 0:
                                    sourceFilename = filename;
                                    sourceFilename = (0, _slash["default"])(sourceFilename);
                                    _context.next = 4;
                                    return util.compile(filename, compileConfig);

                                  case 4:
                                    didCompile = _context.sent;
                                    files++;

                                  case 6:
                                  case "end":
                                    return _context.stop();
                                }
                              }
                            }, _callee);
                          }));

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

                      case 8:
                        results = _context2.sent;
                        end = _perf_hooks.performance.now(); // if (successLog.length + failLog.length > 0) {
                        //   console.log(successLog + failLog)
                        // }

                        fail = compileConfig.errorCount;

                        if (files > 0) {
                          console.log((0, _chalk["default"])(_templateObject4(), files, files > 1 ? 's' : '', fail > 0 ? (0, _chalk["default"])(_templateObject5(), fail, fail > 1 ? 's' : '') : '', Math.round(end - start)));
                        }

                      case 12:
                      case "end":
                        return _context2.stop();
                    }
                  }
                }, _callee2);
              }));
              return _walk.apply(this, arguments);
            };

            walk = function _ref4(_x2) {
              return _walk.apply(this, arguments);
            };

            cliOptions = _ref2.cliOptions, elodinOptions = _ref2.elodinOptions;
            configPath = _path["default"].join(process.cwd(), elodinOptions.configFile);
            _context4.prev = 6;
            config = require(configPath);
            _context4.next = 15;
            break;

          case 10:
            _context4.prev = 10;
            _context4.t0 = _context4["catch"](6);
            console.error((0, _chalk["default"])(_templateObject(), configPath));
            console.error(_context4.t0);
            return _context4.abrupt("return", false);

          case 15:
            filenames = cliOptions.filenames;

            if (config.generator) {
              _context4.next = 19;
              break;
            }

            console.error((0, _chalk["default"])(_templateObject2()));
            return _context4.abrupt("return", false);

          case 19:
            if (cliOptions.clean) {
              if (config.generator.filePattern) {
                didClean = false;
                ignorePattern = config.generator.ignorePattern || [];
                config.generator.filePattern.map(function (v) {
                  try {
                    var _files = _glob["default"].sync(process.cwd() + '/**/' + v);

                    var actualFiles = _files.filter(function (file) {
                      return ignorePattern.find(function (pattern) {
                        return file.indexOf(pattern) !== -1;
                      }) === undefined;
                    });

                    if (actualFiles.length > 0) {
                      console.log('Cleaning ' + actualFiles.length + ' files.');
                      actualFiles.forEach(_fs["default"].unlinkSync);
                      didClean = true;
                    } // config.generator.filePattern
                    //   .map(v => process.cwd() + '/**/' + v)
                    //   .map(path => rimraf.sync(path))
                    // console.log('Successfully cleaned all files.')

                  } catch (e) {// TODO: throw sth
                    // console.log(e)
                  }
                });

                if (didClean) {
                  console.log('');
                }
              }
            }

            if (!cliOptions.filenames.length) {
              _context4.next = 25;
              break;
            }

            _context4.next = 23;
            return files(cliOptions.filenames);

          case 23:
            _context4.next = 25;
            break;

          case 25:
          case "end":
            return _context4.stop();
        }
      }
    }, _callee4, null, [[6, 10]]);
  }));
  return _ref.apply(this, arguments);
}