preconstruct/lib/cli.js

"use strict";

var _meow = _interopRequireDefault(require("meow"));

var _init = _interopRequireDefault(require("./init"));

var _validate = _interopRequireDefault(require("./validate"));

var _build = _interopRequireDefault(require("./build"));

var _watch = _interopRequireDefault(require("./build/watch"));

var _fix = _interopRequireDefault(require("./fix"));

var _dev = _interopRequireDefault(require("./dev"));

var _logger = require("./logger");

var _errors = require("./errors");

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

process.env.NODE_ENV = "production";
let {
  input
} = (0, _meow.default)(`
Usage
  $ preconstruct [command]
Commands
  init         initialise a project
  build        build the project
  watch        start a watch process to build the project
  validate     validate the project
  fix          infer as much information as possible and fix the project
  dev          create links so entrypoints can be imported

`, {});
let errors = {
  commandNotFound: "Command not found"
};

class CommandNotFoundError extends Error {}

(async () => {
  if (input.length === 1) {
    switch (input[0]) {
      case "init":
        {
          await (0, _init.default)(process.cwd());
          return;
        }

      case "validate":
        {
          await (0, _validate.default)(process.cwd());
          return;
        }

      case "build":
        {
          await (0, _build.default)(process.cwd());
          return;
        }

      case "watch":
        {
          await (0, _watch.default)(process.cwd());
          return;
        }

      case "fix":
        {
          await (0, _fix.default)(process.cwd());
          return;
        }

      case "dev":
        {
          await (0, _dev.default)(process.cwd());
          return;
        }

      default:
        {
          throw new CommandNotFoundError();
        }
    }
  } else {
    throw new CommandNotFoundError();
  }
})().catch(err => {
  if (err instanceof _errors.FixableError) {
    (0, _logger.error)(err.message, err.scope);
    (0, _logger.info)("The above error can be fixed automatically by running preconstruct fix", err.item);
  } else if (err instanceof _errors.FatalError) {
    (0, _logger.error)(err.message, err.scope);
  } else if (err instanceof CommandNotFoundError) {
    (0, _logger.error)(errors.commandNotFound);
  } else if (err instanceof _errors.UnexpectedBuildError) {
    (0, _logger.error)(err, err.scope);
  } else {
    (0, _logger.error)(err);
  }

  process.exit(1);
});