bundlib/bin/bundlib-cli.js

#!/usr/bin/env node

'use strict';

var program = require('commander');
var chalk = require('chalk');
var events = require('events');
var genUnit = require('gen-unit');
var path = require('path');
var prettyMs = require('pretty-ms');
var slash = require('slash');
var loadJsonFile = require('load-json-file');
var bundlib_js = require('../dist/bundlib.js');
var fs = require('fs');
var rollup = require('rollup');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var program__default = /*#__PURE__*/_interopDefaultLegacy(program);
var chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
var prettyMs__default = /*#__PURE__*/_interopDefaultLegacy(prettyMs);
var slash__default = /*#__PURE__*/_interopDefaultLegacy(slash);
var loadJsonFile__default = /*#__PURE__*/_interopDefaultLegacy(loadJsonFile);

const name = "bundlib";
const displayName = "Bundlib";
const version = "0.17.8";

function readPkg(cwd) {
  return loadJsonFile__default['default'](path.join(cwd, 'package.json'));
}

const END = 'end';
const BUILD_END = 'build-end';
const REBUILD = 'rebuild';
const WARN = 'warn';
const ERROR = 'error';

function oneByOne(arr, callback, done) {
  let index = 0;
  const len = arr.length;

  const next = error => {
    if (error) {
      return done(error);
    }

    if (index >= len) {
      return done();
    }

    callback(arr[index], next);
    index++;
  };

  next();
}

function build(configs, emitter) {
  const cache = {};
  oneByOne(configs, async (config, next) => {
    const {
      input,
      output
    } = config;
    const {
      file: outputFile,
      format
    } = output;
    const cacheKey = `${format}:${input}`;
    config.cache = cache[cacheKey];

    try {
      const currentTime = Date.now();
      const buildResult = await rollup.rollup(config);
      config.cache = cache[cacheKey] = buildResult.cache;
      await buildResult.write(output);
      const {
        size
      } = fs.statSync(outputFile);
      const totalTime = Date.now() - currentTime;
      emitter.emit(BUILD_END, outputFile, size, totalTime);
    } catch (err) {
      next(err);
      throw err;
    }

    next();
  }, error => {
    if (error) {
      emitter.emit(ERROR, error);
    } else {
      emitter.emit(END);
    }
  });
}

function watch(configs, emitter) {
  let buildIndex = 0;
  const handlers = {
    START() {
      if (buildIndex) {
        emitter.emit(REBUILD, buildIndex);
      }

      buildIndex++;
    },

    END() {
      emitter.emit(END);
    },

    BUNDLE_END(e) {
      const {
        length: len
      } = e.output;

      for (let i = 0; i < len; i++) {
        const stats = fs.statSync(e.output[i]);
        emitter.emit(BUILD_END, e.output[i], stats.size, e.duration);
      }
    },

    ERROR(e) {
      emitter.emit(ERROR, e.error);
    }

  };
  rollup.watch(configs).on('event', event => {
    const handleEvent = handlers[event.code];

    if (handleEvent) {
      handleEvent(event);
    }
  });
}

async function bundlib(cwd, dev, watch$1, emitter, pkg) {
  const onwarn = warning => {
    emitter.emit(WARN, warning);
  };

  (watch$1 ? watch : build)(await bundlib_js.configsFromPkg(cwd, {
    dev,
    watch: watch$1,
    onwarn
  }, pkg), emitter);
}

function create(name) {
  const method = console[name];
  return msg => method(msg);
}

const log = create('log');
const error = create('error');
function logError(err) {
  if (err.stack) {
    error(err.stack);
  }

  const tag = chalk.red.bgWhite.inverse(' error ');
  error(`${tag} ${chalk.red(err.message || err)}`);
}

const {
  bold,
  inverse,
  cyan,
  yellow
} = chalk__default['default'];
const greenBold = bold.green;
const yellowBold = bold.yellow;
const magentaBold = bold.magenta;

function prjInfo(name, ver) {
  const projName = greenBold(name);
  const projVer = yellowBold(`v${ver}`);
  return `${projName} ${projVer}`;
}

if (!chalk__default['default'].level && 'MINGW_CHOST' in process.env) {
  chalk__default['default'].level = 1;
}

async function action(displayName, version, dev, watch, silent) {
  const cwd = process.cwd();
  const pkg = await readPkg(cwd);

  if (!silent) {
    log(`${prjInfo(displayName, version)}
`);
    const {
      name: prjName,
      displayName: prjDispName,
      version: prjVer
    } = pkg;
    const prjInfoName = prjDispName || prjName;

    if (prjInfoName && prjVer) {
      log(`${cyan('building:')} ${prjInfo(prjInfoName, prjVer)}
`);
    }
  }

  const showError = watch ? logError : err => {
    logError(err);
    process.exit(1);
  };
  const emitter = new events.EventEmitter();
  emitter.on(ERROR, showError);

  if (!silent) {
    const formatFileSize = genUnit.createFormatter({
      unit: 'B',
      round: 2,
      find: 1024
    });
    emitter.on(BUILD_END, (filename, size, duration) => {
      const tag = inverse.green(' built ');
      const path$1 = yellowBold(slash__default['default'](path.relative(cwd, filename)));
      const coloredSize = magentaBold(formatFileSize(size));
      const coloredDuration = magentaBold(prettyMs__default['default'](duration, {
        secondsDecimalDigits: 2
      }));
      const info = cyan(`( ${coloredSize} in ${coloredDuration} )`);
      log(`${tag} ${path$1} ${info}`);
    });
    emitter.on(WARN, warning => {
      const {
        plugin,
        message
      } = warning;
      const tag = inverse.yellow(' warning! ');
      const pluginInfo = cyan(`( plugin: ${greenBold(plugin || '<UNKNOWN>')} )`);
      log(`${tag} ${pluginInfo} ${yellow(message)}`);
    });

    if (watch) {
      emitter.on(REBUILD, () => {
        log(cyan(`rebuilding...
`));
      });
      emitter.on(END, () => {
        log(cyan(`
waiting for changes...`));
      });
    }
  }

  try {
    await bundlib(cwd, dev, watch, emitter, pkg);
  } catch (err) {
    showError(err);
  }
}

void program__default['default'].version(version, '-v, --version').name(name).option('-d, --dev', 'create development builds').option('-w, --watch', 'run bundlib in watch mode').option('-s, --silent', 'prevent messages from showing in the console').action(async () => {
  const {
    dev,
    watch,
    silent
  } = program__default['default'];
  await action(displayName, version, dev, watch, silent);
}).parseAsync(process.argv);
//# sourceMappingURL=bundlib-cli.js.map