nps-utils/dist/index.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.commonTags = exports.crossEnv = exports.open = exports.mkdirp = exports.copy = exports.ifNotWindows = exports.ifWindows = exports.rimraf = exports.runInNewWindow = exports.series = exports.concurrent = 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 _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _commonTags = require('common-tags');

var commonTags = _interopRequireWildcard(_commonTags);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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); } }

var defaultColors = ['bgBlue.bold', 'bgMagenta.bold', 'bgGreen.bold', 'bgBlack.bold', 'bgCyan.bold', 'bgRed.bold', 'bgWhite.bold', 'bgYellow.bold'];

exports.concurrent = concurrent;
exports.series = series;
exports.runInNewWindow = runInNewWindow;
exports.rimraf = rimraf;
exports.ifWindows = ifWindows;
exports.ifNotWindows = ifNotWindows;
exports.copy = copy;
exports.mkdirp = mkdirp;
exports.open = open;
exports.crossEnv = crossEnv;
exports.commonTags = commonTags;

/**
 * Accepts any number of scripts, filters out any
 * falsy ones and joins them with ' && '
 * @param {...string} scripts - Any number of strings representing commands
 * @example
 * // returns 'eslint && jest && webpack --env.production'
 * series('eslint', 'jest', 'webpack --env.production')
 * @return {string} - the command that will execute the given scripts in series
 */

function series() {
  for (var _len = arguments.length, scripts = Array(_len), _key = 0; _key < _len; _key++) {
    scripts[_key] = arguments[_key];
  }

  return scripts.filter(Boolean).join(' && ');
}

/**
 * Accepts any number of nps script names, filters out
 * any falsy ones, prepends `nps` to them, and passes
 * the that to `series`
 * @param {...string} scriptNames - the script names to run
 * // returns 'nps lint && nps "test --coverage" && nps build'
 * series.nps('lint', 'test --coverage', 'build')
 * @return {string} - the command that will execute the nps scripts in series
 */
series.nps = function seriesNPS() {
  for (var _len2 = arguments.length, scriptNames = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    scriptNames[_key2] = arguments[_key2];
  }

  return series.apply(undefined, _toConsumableArray(scriptNames.filter(Boolean).map(function (scriptName) {
    return scriptName.trim();
  }).filter(Boolean).map(function (scriptName) {
    return `nps ${quoteScript(scriptName)}`;
  })));
};

/**
 * A concurrent script object
 * @typedef {Object|string} ConcurrentScript
 * @property {string} script - the command to run
 * @property {string} color - the color to use
 *   (see concurrently's docs for valid values)
 */
/**
 * An object of concurrent script objects
 * @typedef {Object.<ConcurrentScript>} ConcurrentScripts
 */

/**
 * Generates a command that uses `concurrently` to run
 * scripts concurrently. Adds a few flags to make it
 * behave as you probably want (like --kill-others-on-fail).
 * In addition, it adds color and labels where the color
 * can be specified or is defaulted and the label is based
 * on the key for the script.
 * @param {ConcurrentScripts} scripts - the scripts to run
 *   note: this function filters out falsy values :)
 * @example
 * // returns a bit of a long script that can vary slightly
 * // based on your environment... :)
 * concurrent({
 *   lint: {
 *     script: 'eslint .',
 *     color: 'bgGreen.white.dim',
 *   },
 *   test: 'jest',
 *   build: {
 *     script: 'webpack'
 *   }
 * })
 * @return {string} - the command to run
 */
function concurrent(scripts) {
  var _Object$keys$reduce = Object.keys(scripts).reduce(reduceScripts, {
    colors: [],
    scripts: [],
    names: []
  }),
      colors = _Object$keys$reduce.colors,
      quotedScripts = _Object$keys$reduce.scripts,
      names = _Object$keys$reduce.names;

  var flags = ['--kill-others-on-fail', `--prefix-colors "${colors.join(',')}"`, '--prefix "[{name}]"', `--names "${names.join(',')}"`, shellEscape(quotedScripts)];
  var concurrently = getBin('concurrently');
  return `${concurrently} ${flags.join(' ')}`;

  function reduceScripts(accumulator, scriptName, index) {
    var scriptObj = scripts[scriptName];
    if (!scriptObj) {
      return accumulator;
    } else if (typeof scriptObj === 'string') {
      scriptObj = { script: scriptObj };
    }
    var _scriptObj = scriptObj,
        script = _scriptObj.script,
        _scriptObj$color = _scriptObj.color,
        color = _scriptObj$color === undefined ? defaultColors[index % defaultColors.length] : _scriptObj$color;

    if (!script) {
      return accumulator;
    }
    accumulator.names.push(scriptName);
    accumulator.colors.push(color);
    accumulator.scripts.push(script);
    return accumulator;
  }
}

/**
 * Accepts any number of nps script names, filters out
 * any falsy ones, prepends `nps` to them, and passes
 * the that to `concurrent`
 * @param {...string} scriptNames - the script names to run
 * @example
 * // will basically return `nps lint & nps "test --coverage" & nps build`
 * // but with the concurrently command and relevant flags to make
 * // it super awesome with colors and whatnot. :)
 * concurrent.nps('lint', 'test --coverage', 'build')
 * @return {string} the command to run
 */
concurrent.nps = function concurrentNPS() {
  for (var _len3 = arguments.length, scriptNames = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
    scriptNames[_key3] = arguments[_key3];
  }

  return concurrent(scriptNames.map(mapNPSScripts).reduce(reduceNPSScripts, {}));

  function mapNPSScripts(scriptName, index) {
    var color = defaultColors[index];
    if (!Boolean(scriptName)) {
      return undefined;
    } else if (typeof scriptName === 'string') {
      return { script: scriptName, color };
    } else {
      return Object.assign({ color }, scriptName);
    }
  }

  function reduceNPSScripts(scripts, scriptObj) {
    if (!scriptObj) {
      return scripts;
    }
    var color = scriptObj.color,
        script = scriptObj.script;

    var _script$split = script.split(' '),
        _script$split2 = _slicedToArray(_script$split, 1),
        name = _script$split2[0];

    scripts[name] = {
      script: `nps ${quoteScript(script.trim())}`,
      color
    };
    return scripts;
  }
};

/**
 * EXPERIMENTAL: THIS DOES NOT CURRENTLY WORK FOR ALL TERMINALS
 * Takes a command and returns a version that should run in
 * another tab/window of your terminal. Currently only supports
 * Windows cmd (new window) and Terminal.app (new tab)
 * @param {string} command - the command to run in a new tab/window
 * @example
 * // returns some voodoo magic to make the terminal do what you want
 * runInNewWindow('echo hello')
 * @return {string} - the command to run
 */
function runInNewWindow(command) {
  return isWindows() ? `start cmd /k "cd ${process.cwd()} && ${command}"` : commonTags.oneLine`
      osascript
      -e 'tell application "Terminal"'
      -e 'tell application "System Events"
      to keystroke "t" using {command down}'
      -e 'do script "cd ${process.cwd()} && ${command}" in front window'
      -e 'end tell'
    `;
}

/**
 * EXPERIMENTAL: THIS DOES NOT CURRENTLY WORK FOR ALL TERMINALS
 * Takes an nps script name and prepends it with a call to nps
 * then forwards that to `runInNewWindow` properly escaped.
 * @param {string} scriptName - the name of the nps script to run
 * @example
 * // returns a script that runs
 * // `node node_modules/.bin/nps "lint --cache"`
 * // in a new tab/window
 * runInNewWindow.nps('lint --cache')
 * @return {string} - the command to run
 */
runInNewWindow.nps = function runInNewWindowNPS(scriptName) {
  var escaped = true;
  return runInNewWindow(`node node_modules/.bin/nps ${quoteScript(scriptName, escaped)}`);
};

/**
 * Gets a script that uses the rimraf binary. rimraf
 * is a dependency of nps-utils, so you don't need to
 * install it yourself.
 * @param {string} args - args to pass to rimraf
 *   learn more from http://npm.im/rimraf
 * @return {string} - the command with the rimraf binary
 */
function rimraf(args) {
  return `${getBin('rimraf')} ${args}`;
}

/**
 * Takes two scripts and returns the first if the
 * current environment is windows, and the second
 * if the current environment is not windows
 * @param {string} script - the script to use for windows
 * @param {string} altScript - the script to use for non-windows
 * @return {string} - the command to run
 */
function ifWindows(script, altScript) {
  return isWindows() ? script : altScript;
}

/**
 * Simply calls ifWindows(altScript, script)
 * @param {string} script - the script to use for non-windows
 * @param {string} altScript - the script to use for windows
 * @return {string} - the command to run
 */
function ifNotWindows(script, altScript) {
  return ifWindows(altScript, script);
}

/**
 * Gets a script that uses the cpy-cli binary. cpy-cli
 * is a dependency of nps-utils, so you don't need to
 * install it yourself.
 * @param {string} args - args to pass to cpy-cli
 *   learn more from http://npm.im/cpy-cli
 * @return {string} - the command with the cpy-cli binary
 */
function copy(args) {
  return `${getBin('cpy-cli', 'cpy')} ${args}`;
}

/**
 * Gets a script that uses the mkdirp binary. mkdirp
 * is a dependency of nps-utils, so you don't need to
 * install it yourself.
 * @param {string} args - args to pass to mkdirp
 *   learn more from http://npm.im/mkdirp
 * @return {string} - the command with the mkdirp binary
 */
function mkdirp(args) {
  return `${getBin('mkdirp')} ${args}`;
}

/**
 * Gets a script that uses the opn-cli binary. opn-cli
 * is a dependency of nps-utils, so you don't need to
 * install it yourself.
 * @param {string} args - args to pass to opn-cli
 *   learn more from http://npm.im/opn-cli
 * @return {string} - the command with the opn-cli binary
 */
function open(args) {
  return `${getBin('opn-cli', 'opn')} ${args}`;
}

/**
 * Gets a script that uses the cross-env binary. cross-env
 * is a dependency of nps-utils, so you don't need to
 * install it yourself.
 * @param {string} args - args to pass to cross-env
 *   learn more from http://npm.im/cross-env
 * @return {string} - the command with the cross-env binary
 */
function crossEnv(args) {
  return `${getBin('cross-env')} ${args}`;
}

// utils

function quoteScript(script, escaped) {
  var quote = escaped ? '\\"' : '"';
  var shouldQuote = script.indexOf(' ') !== -1;
  return shouldQuote ? `${quote}${script}${quote}` : script;
}

function getBin(packageName) {
  var binName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : packageName;

  var packagePath = require.resolve(`${packageName}/package.json`);
  var concurrentlyDir = _path2.default.dirname(packagePath);

  var _require = require(packagePath),
      binRelativeToPackage = _require.bin;

  if (typeof binRelativeToPackage === 'object') {
    binRelativeToPackage = binRelativeToPackage[binName];
  }
  var fullBinPath = _path2.default.join(concurrentlyDir, binRelativeToPackage);
  var relativeBinPath = _path2.default.relative(process.cwd(), fullBinPath);
  return `node ${relativeBinPath}`;
}

function isWindows() {
  // lazily require for perf :)
  return require('is-windows')();
}

function shellEscape() {
  // lazily require for perf :)
  return require('any-shell-escape').apply(undefined, arguments);
}

/*
  eslint
    func-name-matching:0,
    global-require:0,
    import/no-dynamic-require:0
*/