@wpk-cli/cli/dist/command-run.js

an unofficial CLI for webpack

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

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

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));

var _get = _interopRequireDefault(require("lodash/get"));

var _last = _interopRequireDefault(require("lodash/last"));

var _isUndefined = _interopRequireDefault(require("lodash/isUndefined"));

var _forEach = _interopRequireDefault(require("lodash/forEach"));

var _isNumber = _interopRequireDefault(require("lodash/isNumber"));

var _isFunction = _interopRequireDefault(require("lodash/isFunction"));

var _logger = _interopRequireDefault(require("@wpk-cli/logger"));

var _commander = _interopRequireDefault(require("commander"));

var _prompt = _interopRequireDefault(require("@wpk-cli/prompt"));

var _utilities = require("@wpk-cli/utilities");

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

/**
 * Execute a wpk command.
 * @param command {Object} the wpk command definition
 * @param args {Array} arguments to the command fn from Commander
 */
function runCommand(_x, _x2) {
  return _runCommand.apply(this, arguments);
}

function _runCommand() {
  _runCommand = (0, _asyncToGenerator2.default)(function* (command, args) {
    // get the Command object which has option (flag) values
    const cmd = (0, _cloneDeep.default)((0, _last.default)(args)); // set command arguments as properties on cmd

    (0, _forEach.default)(cmd._args, ({
      name
    }, i) => {
      if (!(0, _isUndefined.default)(args[i])) {
        cmd[name] = args[i];
      }
    });

    if (cmd.wpkDebug) {
      process.env.WPK_DEBUG = true;
      Error.stackTraceLimit = Infinity;
    }

    if ((0, _isFunction.default)(command.setup)) {
      command.setup(cmd);
    }

    if (cmd.quiet) {
      _logger.default.off();
    }

    let scope;

    if (cmd.webpack === "local" || cmd.webpack === "global") {
      scope = cmd.webpack;
    } else if (cmd.webpack) {
      _logger.default.error('bad value for --webpack, expecting "local" or "global"');

      return;
    }

    if (!cmd.wpkInfo) {
      // TODO not a great way of doing this...
      global.wpk.noInfoLogs = true;
    }

    const webpack = (0, _utilities.getWebpack)(scope);
    const info = (0, _util.logCommandInfo)(cmd._name);
    global.wpk.initialise({
      program: _commander.default,
      command,
      cmd,
      info
    });
    (0, _util.prepareCmd)(cmd); // may be set in a command#setup function

    /* istanbul ignore if */

    if (cmd.clearScreen) {
      global.wpk.clear();
    }

    (0, _util.logWebpackInfo)(webpack, scope);
    (0, _util.logEnvInfo)();

    if (!cmd.quiet) {
      (0, _util.checkForUpdateMaybe)(cmd);
    }

    if (cmd.wpkDebug) {
      _logger.default.debug("startup took", Date.now() - global.WPK_START_TIME + "ms");

      _logger.default.debug("command started");
    }

    if (process.env.WPK_PROFILE) {
      _logger.default.info("profiling enabled");
    }

    const run = command.get();
    let result;

    if ((0, _isFunction.default)(run)) {
      result = yield run(cmd, webpack);
    } else if ((0, _get.default)(run, "constructor") === _prompt.default) {
      result = yield run.run(cmd, webpack);
    } else {
      (0, _util.printCommandError)(new Error("command#get did not return function or WpkPrompt"), command, "run");
      result = 1;
    }

    if ((0, _isNumber.default)(result)) {
      global.wpk.exit(result);
    } else if (result === false) {
      global.wpk.exit(1);
    } else if (result instanceof Error) {
      if (cmd.wpkDebug) {
        (0, _utilities.printError)(result);
      } else {
        _logger.default.error(result.message);
      }

      global.wpk.exit(result.code || 1);
    } else {
      global.wpk.exit(0);
    }
  });
  return _runCommand.apply(this, arguments);
}