Initial import with skill sheet working

node_modules/bach/lib/helpers.js

@@ -0,0 +1,94 @@
+'use strict';
+
+function noop() {}
+
+function getOptions(args) {
+  // TODO: use `.at(-1)` when the API is available
+  var lastArg = args.slice(-1)[0];
+
+  if (typeof lastArg !== 'function') {
+    return lastArg;
+  }
+}
+
+function filterSuccess(elem) {
+  return elem.state === 'success';
+}
+
+function filterError(elem) {
+  return elem.state === 'error';
+}
+
+function pluckValue(elem) {
+  return elem.value;
+}
+
+function buildOnSettled(done) {
+  if (typeof done !== 'function') {
+    done = noop;
+  }
+
+  function onSettled(error, result) {
+    if (error) {
+      return done(error, null);
+    }
+
+    if (!Array.isArray(result)) {
+      result = [];
+    }
+
+    var settledErrors = result.filter(filterError);
+    var settledResults = result.filter(filterSuccess);
+
+    var errors = null;
+    if (settledErrors.length) {
+      errors = settledErrors.map(pluckValue);
+    }
+
+    var results = null;
+    if (settledResults.length) {
+      results = settledResults.map(pluckValue);
+    }
+
+    done(errors, results);
+  }
+
+  return onSettled;
+}
+
+function verifyArguments(args) {
+  args = Array.prototype.concat.apply([], args);
+
+  if (!args.length) {
+    throw new Error('A set of functions to combine is required');
+  }
+
+  args.forEach(verifyEachArg);
+
+  return args;
+}
+
+function verifyEachArg(arg, argIdx, args) {
+  var isFunction = typeof arg === 'function';
+  if (isFunction) {
+    return;
+  }
+
+  if (argIdx === args.length - 1) {
+    // Last arg can be an object of extension points
+    return;
+  }
+
+  var msg =
+    'Only functions can be combined, got ' +
+    typeof arg +
+    ' for argument ' +
+    argIdx;
+  throw new Error(msg);
+}
+
+module.exports = {
+  getOptions: getOptions,
+  onSettled: buildOnSettled,
+  verifyArguments: verifyArguments,
+};

node_modules/bach/lib/parallel.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var asyncDone = require('async-done');
+var nowAndLater = require('now-and-later');
+
+var helpers = require('./helpers');
+
+function iterator(fn, key, cb) {
+  return asyncDone(fn, cb);
+}
+
+function buildParallel() {
+  var args = helpers.verifyArguments(arguments);
+
+  var options = helpers.getOptions(args);
+
+  if (options) {
+    args = args.slice(0, -1);
+  }
+
+  function parallel(done) {
+    nowAndLater.map(args, iterator, options, done);
+  }
+
+  return parallel;
+}
+
+module.exports = buildParallel;

node_modules/bach/lib/series.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var asyncDone = require('async-done');
+var nowAndLater = require('now-and-later');
+
+var helpers = require('./helpers');
+
+function iterator(fn, key, cb) {
+  return asyncDone(fn, cb);
+}
+
+function buildSeries() {
+  var args = helpers.verifyArguments(arguments);
+
+  var options = helpers.getOptions(args);
+
+  if (options) {
+    args = args.slice(0, -1);
+  }
+
+  function series(done) {
+    nowAndLater.mapSeries(args, iterator, options, done);
+  }
+
+  return series;
+}
+
+module.exports = buildSeries;

node_modules/bach/lib/settleParallel.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var asyncSettle = require('async-settle');
+var nowAndLater = require('now-and-later');
+
+var helpers = require('./helpers');
+
+function iterator(fn, key, cb) {
+  return asyncSettle(fn, cb);
+}
+
+function buildSettleParallel() {
+  var args = helpers.verifyArguments(arguments);
+
+  var options = helpers.getOptions(args);
+
+  if (options) {
+    args = args.slice(0, -1);
+  }
+
+  function settleParallel(done) {
+    var onSettled = helpers.onSettled(done);
+    nowAndLater.map(args, iterator, options, onSettled);
+  }
+
+  return settleParallel;
+}
+
+module.exports = buildSettleParallel;

node_modules/bach/lib/settleSeries.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var asyncSettle = require('async-settle');
+var nowAndLater = require('now-and-later');
+
+var helpers = require('./helpers');
+
+function iterator(fn, key, cb) {
+  return asyncSettle(fn, cb);
+}
+
+function buildSettleSeries() {
+  var args = helpers.verifyArguments(arguments);
+
+  var options = helpers.getOptions(args);
+
+  if (options) {
+    args = args.slice(0, -1);
+  }
+
+  function settleSeries(done) {
+    var onSettled = helpers.onSettled(done);
+    nowAndLater.mapSeries(args, iterator, options, onSettled);
+  }
+
+  return settleSeries;
+}
+
+module.exports = buildSettleSeries;