@zambezi/ez-build/lib/cli/opts.js

'use strict';

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

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 explode = function () {
  var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(argv) {
    var exploded, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, arg, file, fileopts;

    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            exploded = [];
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _iteratorError = undefined;
            _context2.prev = 4;
            _iterator = argv[Symbol.iterator]();

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

            arg = _step.value;

            if (!arg.startsWith('@')) {
              _context2.next = 27;
              break;
            }

            file = arg.slice(1);
            _context2.prev = 10;
            _context2.next = 13;
            return (0, _file.slurp)(file, 'utf8');

          case 13:
            fileopts = _context2.sent.split(/\s/);
            _context2.t0 = exploded;
            _context2.next = 17;
            return explode(fileopts);

          case 17:
            _context2.t1 = _context2.sent;
            exploded = _context2.t0.concat.call(_context2.t0, _context2.t1);
            _context2.next = 25;
            break;

          case 21:
            _context2.prev = 21;
            _context2.t2 = _context2['catch'](10);

            console.error(_context2.t2.message);
            process.exit(1);

          case 25:
            _context2.next = 28;
            break;

          case 27:
            if (arg) {
              exploded.push(arg);
            }

          case 28:
            _iteratorNormalCompletion = true;
            _context2.next = 6;
            break;

          case 31:
            _context2.next = 37;
            break;

          case 33:
            _context2.prev = 33;
            _context2.t3 = _context2['catch'](4);
            _didIteratorError = true;
            _iteratorError = _context2.t3;

          case 37:
            _context2.prev = 37;
            _context2.prev = 38;

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

          case 40:
            _context2.prev = 40;

            if (!_didIteratorError) {
              _context2.next = 43;
              break;
            }

            throw _iteratorError;

          case 43:
            return _context2.finish(40);

          case 44:
            return _context2.finish(37);

          case 45:
            return _context2.abrupt('return', exploded);

          case 46:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, this, [[4, 33, 37, 45], [10, 21], [38,, 40, 44]]);
  }));

  return function explode(_x3) {
    return _ref2.apply(this, arguments);
  };
}();

var _commander = require('commander');

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

var _pkginfo = require('pkginfo');

var _pkginfo2 = _interopRequireDefault(_pkginfo);

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;

exports.default = function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(pkg, argv) {
    var alwaysExclude, defaults, cli, opts, rawFlags;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            alwaysExclude = [`node_modules`, `package.json`, `.*`, `*-min.js`, `*-min.js.map`, `*-min.css`, `*-min.css.map`, `*-debug.log`, `optimised-modules.json`, `dependencies.json`];
            defaults = { out: pkg.relative(`${pkg.name.split('/').pop()}-min`),
              lib: pkg.relative(pkg.directories.lib || 'lib'),
              src: pkg.relative(pkg.directories.src || 'src'),
              optimize: 0,
              copy: true,
              debug: true,
              interactive: false,
              production: false,
              include: ['js:**/*.js', 'css:**/*.css'],
              exclude: [].concat(alwaysExclude),
              log: 'normal',
              flags: keys(defaultFlags).map(function (f) {
                return `${f}:${defaultFlags[f]}`;
              }),
              rawArgs: [],
              targetNode: false,
              targetBrowsers: ['last 3 versions']
            };
            cli = new _commander.Command().version((0, _pkginfo2.default)(module).version).option('-i, --src <dir>', `the root directory from which all sources are relative [${defaults.src}]`, pkg.relative, defaults.src).option('-o, --out <prefix>', `write optimized output to files with the specified prefix [${defaults.out}]`, pkg.relative, defaults.out).option('-L, --lib <dir>', `write unoptimized files to the specified directory [${defaults.lib}]`, pkg.relative, defaults.lib).option('-I, --include [js|css:]<path>', `include a path or glob (relative to source root) [${defaults.include}]`, concatGlobs, []).option('-X, --exclude [js|css:]<path>', `exclude a path or glob (relative to source root) [${defaults.exclude}]`, concatGlobs, []).option('-O, --optimize <level>', `optimization level (0 = none) [${defaults.optimize}]`, setOptimization, defaults.optimize).option('--no-copy', `disable copying of non-code files to ${defaults.lib}`, Boolean, !defaults.copy).option('--no-debug', 'disable source map generation', Boolean, !defaults.debug).option('--log <normal|json>', `log output format [${defaults.log}]`, /^(json|normal)$/i, defaults.log).option('--interactive [cmd]', `watch for and recompile on changes (implies -O 0)`).option('--production', `enable production options (implies -O 1)`).option('--target-browsers <spec|false>', `define target browser environments:  [${defaults.targetBrowsers}]`, concatFlags, []).option('--target-node <current|number|false>', `define target node environment: [${defaults.targetNode}]`, defaults.targetNode).option('--flags <flags>', `toggle flags [${defaults.flags}]`, concatFlags, []).option('@<path>', 'read options from the file at <path> (relative to cwd)');
            _context.t0 = cli;
            _context.next = 6;
            return explode(argv);

          case 6:
            _context.t1 = _context.sent;
            opts = _context.t0.parse.call(_context.t0, _context.t1);


            Object.keys(opts).forEach(function (key) {
              if (key in defaults === false) {
                delete opts[key];
              }
            });

            opts.rawCommand = opts.rawArgs.join(' ');

            opts.include = conclude(['js', 'css'], defaults.include, opts.include);
            opts.exclude = conclude(['js', 'css'], defaults.exclude, opts.exclude);

            if (opts.targetBrowsers.length === 0) {
              opts.targetBrowsers = defaults.targetBrowsers;
            } else if (opts.targetBrowsers.length === 1 && opts.targetBrowsers[0] === 'false') {
              opts.targetBrowsers = false;
            }

            if (opts.targetNode !== 'current') {
              opts.targetNode = Number(opts.targetNode) || false;
            }

            rawFlags = flag(defaults.flags, opts.flags);


            opts.flags = keys(rawFlags).reduce(function (flags, name) {
              if (name in validFlags) {
                var value = rawFlags[name];

                if (validFlags[name].some(function (valid) {
                  return value === valid;
                })) {
                  flags[name] = value;
                } else if (defaultFlags[name]) {
                  flags[name] = defaultFlags[name];
                }
              }

              return flags;
            }, {});

            opts.include['copy-files'] = ['**/*'];
            opts.exclude['copy-files'] = [].concat(_toConsumableArray(opts.include.js), _toConsumableArray(opts.include.css), _toConsumableArray(opts.exclude['*']));

            if (process.env.NODE_ENV === 'production' && !opts.interactive) {
              opts.production = true;
            }

            opts.optimize = opts.production ? 1 : opts.interactive ? 0 : opts.optimize;

            opts.interactive = opts.production ? false : opts.interactive;

            return _context.abrupt('return', opts);

          case 22:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

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

  return parse;
}();

var validFlags = exports.validFlags = { 'react': [undefined, true, false],
  'modules': ['umd', 'amd', 'ecmascript', 'commonjs', 'systemjs'],
  'es-stage': [0, 1, 2, 3],
  'add-module-exports': [undefined, true, false]
};

var defaultFlags = exports.defaultFlags = { 'modules': 'umd' };

function conclude(types, defaults, opts) {
  return Object.assign([].concat(_toConsumableArray(new Set(defaults))).reduce(parse, {}), [].concat(_toConsumableArray(new Set(opts))).reduce(parse, {}));

  function parse(pipe, val) {
    var _val$split = val.split(':'),
        _val$split2 = _slicedToArray(_val$split, 2),
        lines = _val$split2[0],
        pattern = _val$split2[1];

    if (pattern) {
      lines = [lines];
    } else {
      pattern = lines;
      lines = ['*'].concat(_toConsumableArray(types));
    }

    lines.forEach(function (line) {
      pipe[line] = (pipe[line] || []).concat(pattern);
    });

    return pipe;
  }
}

function flag(defaults, opts) {
  return Object.assign([].concat(_toConsumableArray(new Set(defaults))).reduce(parse, {}), [].concat(_toConsumableArray(new Set(opts))).reduce(parse, {}));

  function parse(flags, val) {
    var _val$split3 = val.split(':'),
        _val$split4 = _slicedToArray(_val$split3, 2),
        flag = _val$split4[0],
        setting = _val$split4[1];

    if (setting) {
      try {
        flags[flag] = JSON.parse(setting);
      } catch (e) {
        flags[flag] = setting;
      }
    } else {
      flags[flag] = true;
    }

    return flags;
  }
}

function setOptimization(level) {
  return Math.max(level | 0, 0);
}

function concatGlobs(val, list) {
  var prep = val.replace(/,([^,:]+:)/g, "\0$1");
  return list.concat(prep.split('\0'));
}

function concatFlags(val, list) {
  return list.concat(val.split(/\s*,\s*/));
}
//# sourceMappingURL=opts.js.map