@eknkc/maket/build/bin.js

#!/usr/bin/env node
'use strict';

var _commander = require('commander');

var _commander2 = _interopRequireDefault(_commander);

var _child_process = require('child_process');

var _child_process2 = _interopRequireDefault(_child_process);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _tsort = require('tsort');

var _tsort2 = _interopRequireDefault(_tsort);

var _stream = require('stream');

var _stream2 = _interopRequireDefault(_stream);

var _maketConf = require('@eknkc/maket-conf');

var _maketConf2 = _interopRequireDefault(_maketConf);

var _flatten = require('./flatten');

var _flatten2 = _interopRequireDefault(_flatten);

var _lodash = require('lodash.template');

var _lodash2 = _interopRequireDefault(_lodash);

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

const json = require.resolve('.bin/json');
const concurrently = require.resolve('.bin/concurrently');
const nodemon = require.resolve('.bin/nodemon');
const babel = require.resolve('.bin/babel');
const stylus = require.resolve('.bin/stylus');
const babelParams = ['-s', 'inline', '-D'];
const cwd = process.cwd();

const config = (0, _maketConf2.default)(cwd);

if (!config) exit("No maket.yaml config found.");

function resolve(path, name = path) {
  try {
    let res = _child_process2.default.spawnSync('/usr/bin/env', ['node', '-e', 'process.stdout.write(require.resolve(process.argv[1]))', path], { cwd });

    if (res.status !== 0) throw new Error();

    return res.stdout.toString('utf8');
  } catch (e) {
    return exit(`Unable to resolve ${ name }`);
  }
}

_commander2.default.command('browserify').option('-w, --watch', 'Watch mode').description("Build browserify bundle").action(function () {
  const browserify = require('browserify');
  const watchify = require('watchify');
  const browserifycss = require('browserify-css');
  const babelify = require('babelify');
  const envify = require('envify/custom');
  const factor = require('factor-bundle');

  if (!config.$browserify) return exit("No browserify configuration found.");

  let cnf = config.$browserify;

  if (!Array.isArray(cnf)) cnf = [cnf];

  cnf.forEach(cf => {
    if (!cf.add || !cf.dest) return exit("Browserify needs an add and dest field");
    if (!Array.isArray(cf.add)) cf.add = [cf.add];
    cf.add = cf.add.map(a => _path2.default.resolve(cwd, a));

    var b = browserify(cf.add, {
      extensions: [".js", ".jsx", ".json", ".css"],
      paths: [_path2.default.join(cwd, 'node_modules')],
      cache: {},
      packageCache: {},
      debug: !!this.watch
    }).transform(babelify, { presets: [require('babel-preset-es2015'), require('babel-preset-react')] }).transform(browserifycss, {
      global: true,
      onFlush({ data }, done) {
        done(`
          (function() {
            var elem = document.createElement('style');
            var css = ${ JSON.stringify(data) };
            elem.setAttribute('type', 'text/css');

            if ('textContent' in elem) {
              elem.textContent = css;
            } else {
              elem.styleSheet.cssText = css;
            }

            var head = document.getElementsByTagName('head')[0];
            head.appendChild(elem);
          })();
        `);
      }
    }).transform(envify({
      NODE_ENV: this.watch ? 'development' : 'production'
    }), {
      global: true
    }).transform((filename, opts) => {
      if (this.watch || /\.min\./.test(filename) || /\.json$/.test(filename)) return new _stream2.default.PassThrough();

      var uglifyjs = require('uglify-js');

      var js = "";
      var transform = new _stream2.default.Transform();

      transform._transform = function (data, enc, next) {
        js += data.toString('utf8');
        next();
      };

      transform._flush = function (next) {
        try {
          js = uglifyjs.minify(js, { fromString: true }).code;
          this.push(js);
          next(null);
        } catch (e) {
          next(e);
        }
      };

      return transform;
    }, {
      global: true
    });

    if (cf.factor && Array.isArray(cf.factor)) b.plugin(factor, { outputs: cf.factor.map(f => _path2.default.resolve(cwd, f)) });

    bundle();

    if (this.watch) {
      b.plugin(watchify);
      b.on('update', bundle);
    }

    function bundle() {
      b.bundle().on('error', function (err) {
        console.log("browserify", "error");

        if (err._babel && err instanceof SyntaxError) {
          console.log(`${ err.name }: ${ err.message }\n${ err.codeFrame }`);
        } else if (err.stack) {
          console.log(err.stack);
        } else {
          console.log(err);
        }
      }).pipe(_fs2.default.createWriteStream(_path2.default.resolve(cwd, cf.dest))).on('close', () => {
        console.log('browserify', 'buildEnd', cf.dest);
      });
    }
  });
});

_commander2.default.command('stylus').option('-w, --watch', 'Watch mode').description("Build stylus").action(function () {
  if (!config.$stylus) return exit("No stylus configuration found.");

  let entry = config.$stylus.entry;
  let dest = config.$stylus.dest;

  if (!entry || !dest) return exit("Malformed stylus config.");

  let params = ['-u', require.resolve('nib'), '-u', require.resolve('jeet'), '-u', require.resolve('rupture')];

  if (this.watch) params.push('-w', "--sourcemap-inline");else params.push('--compress');

  if (config.$stylus.paths) {
    config.$stylus.paths.forEach(p => params.push('-I', _path2.default.resolve(cwd, p)));
  }

  params.push('--out', _path2.default.resolve(cwd, dest));
  params.push(_path2.default.resolve(cwd, entry));

  console.log('stylus', this.watch ? 'watch' : 'buildStart', dest);
  _child_process2.default.spawnSync(stylus, params, {
    stdio: ['ignore', 'ignore', 'inherit'],
    cwd: __dirname
  });
  console.log('stylus', 'buildEnd', dest);
});

_commander2.default.command('babel').option('-w, --watch', 'Watch mode').description("Build babel").action(function () {
  if (!config.$babel) return exit("No babel configuration found.");

  let source = config.$babel.source;
  let dest = config.$babel.dest;

  if (!source || !dest) return exit("Babel requires source and dest.");

  let params = [...babelParams];

  params.push('--presets', [require.resolve('babel-preset-es2015-node'), require.resolve('babel-preset-stage-3')].join(','));

  if (this.watch) params.push('--watch');

  params.push('--out-dir', _path2.default.resolve(cwd, dest), _path2.default.resolve(cwd, source));

  console.log('babel', this.watch ? 'watch' : 'buildStart', source, dest);
  _child_process2.default.spawnSync(babel, params, {
    stdio: ['ignore', 'ignore', 'inherit'],
    cwd: __dirname
  });
  console.log('babel', 'buildEnd', source, dest);
});

_commander2.default.command('json [args...]').description("JSON helper").action(function (args) {
  _child_process2.default.spawnSync(json, args, { stdio: 'inherit' });
});

_commander2.default.command('concurrent [args...]').description("Run multiple shell commands at once").action(function (args) {
  _child_process2.default.spawnSync(concurrently, ['-k', ...args], { stdio: 'inherit' });
});

_commander2.default.command('nodemon -- [args...]').description("Nodemon proxy").action(function (args) {
  _child_process2.default.spawnSync(nodemon, args, { stdio: 'inherit' });
});

_commander2.default.command('run <script> [args...]').description("Run a maket script").action(function (script, args) {
  let scripts = {};
  let graph = (0, _tsort2.default)();

  addScript(script);

  function addScript(name) {
    if (scripts[name]) return;

    let scr = getScript(name);
    scripts[name] = scr;

    graph.add(name);

    if (scr.after.length) {
      scr.after.forEach(addScript);
      graph.add([...scr.after, name]);
    }

    if (scr.before.length) {
      scr.before.forEach(addScript);
      graph.add([name, ...scr.before]);
    }
  }

  let queue;

  try {
    queue = graph.sort().map(s => scripts[s]);
  } catch (e) {
    return exit("There is a cycle in script order.");
  }

  let env = {
    MAKET: __filename
  };

  let fconf = (0, _flatten2.default)(config);

  Object.keys(fconf).forEach(k => {
    if (k.indexOf('$') >= 0) return;

    env[`MAKET_${ k.toUpperCase().replace(/[\.\[\]]/g, '_') }`] = fconf[k];
  });

  let proc = _child_process2.default.spawn('/usr/bin/env', ['bash'], {
    stdio: ['pipe', 'inherit', 'inherit'],
    env: Object.assign({}, process.env, env)
  });

  proc.stdin.write('set -e\n');

  queue.forEach(q => {
    q.commands.forEach(c => {
      proc.stdin.write(c + '\n');
    });
  });

  proc.stdin.end();
});

_commander2.default.command('tpl <filename>').description("Render template").action(function (filename) {
  let tpl;

  try {
    tpl = _fs2.default.readFileSync(_path2.default.resolve(cwd, filename), { encoding: 'utf8' });
  } catch (e) {
    return exit("Unable to read file: " + filename);
  }

  process.stdout.write((0, _lodash2.default)(tpl)(Object.assign({ encode }, config)));

  function encode(value) {
    return JSON.stringify(value).replace(/^"/, "").replace(/"$/, "");
  }
});

_commander2.default.command('config [path]').description("Get maket configuration").action(function (cpath) {
  let res = config;

  if (cpath) res = res[cpath];

  if (typeof res === 'string') return process.stdout.write(res);

  process.stdout.write(JSON.stringify(res, null, "  "));
});

_commander2.default.parse(process.argv);

function exit(message, code = -1) {
  console.error(message);
  process.exit(code);
}

function getScript(name) {
  let scripts = config.$scripts || {};
  let scr = scripts[name];

  if (!scr) return exit("Script not found.");

  if (typeof scr === 'string') scr = { commands: [scr] };else if (Array.isArray(scr)) scr = { commands: scr };

  scr.after = scr.run_after || [];
  scr.before = scr.run_before || [];
  scr.commands = scr.commands || scr.cmd || [];

  if (!Array.isArray(scr.after)) scr.after = [scr.after];
  if (!Array.isArray(scr.before)) scr.before = [scr.before];
  if (!Array.isArray(scr.commands)) scr.commands = [scr.commands];

  return scr;
}