diff options
Diffstat (limited to 'build/es')
82 files changed, 1613 insertions, 0 deletions
diff --git a/build/es/apply.js b/build/es/apply.js new file mode 100644 index 0000000..eeceb43 --- /dev/null +++ b/build/es/apply.js @@ -0,0 +1,9 @@ +'use strict'; + +import rest from 'lodash-es/rest'; + +export default rest(function(fn, args) { + return rest(function(callArgs) { + return fn.apply(null, args.concat(callArgs)); + }); +}); diff --git a/build/es/applyEach.js b/build/es/applyEach.js new file mode 100644 index 0000000..2c5f001 --- /dev/null +++ b/build/es/applyEach.js @@ -0,0 +1,6 @@ +'use strict'; + +import applyEach from './internal/applyEach'; +import eachOf from './eachOf'; + +export default applyEach(eachOf); diff --git a/build/es/applyEachSeries.js b/build/es/applyEachSeries.js new file mode 100644 index 0000000..e917618 --- /dev/null +++ b/build/es/applyEachSeries.js @@ -0,0 +1,6 @@ +'use strict'; + +import applyEach from './internal/applyEach'; +import eachOfSeries from './eachOfSeries'; + +export default applyEach(eachOfSeries); diff --git a/build/es/asyncify.js b/build/es/asyncify.js new file mode 100644 index 0000000..9239e99 --- /dev/null +++ b/build/es/asyncify.js @@ -0,0 +1,26 @@ +'use strict'; + +import isObject from 'lodash-es/isObject'; +import rest from 'lodash-es/rest'; + +export default function asyncify(func) { + return rest(function (args) { + var callback = args.pop(); + var result; + try { + result = func.apply(this, args); + } catch (e) { + return callback(e); + } + // if result is Promise object + if (isObject(result) && typeof result.then === 'function') { + result.then(function(value) { + callback(null, value); + })['catch'](function(err) { + callback(err.message ? err : new Error(err)); + }); + } else { + callback(null, result); + } + }); +} diff --git a/build/es/auto.js b/build/es/auto.js new file mode 100644 index 0000000..19f4215 --- /dev/null +++ b/build/es/auto.js @@ -0,0 +1,109 @@ +'use strict'; + +import arrayEach from 'lodash-es/internal/arrayEach'; +import arrayEvery from 'lodash-es/internal/arrayEvery'; +import baseHas from 'lodash-es/internal/baseHas'; +import forOwn from 'lodash-es/forOwn'; +import indexOf from 'lodash-es/indexOf'; +import isArray from 'lodash-es/isArray'; +import okeys from 'lodash-es/keys'; +import noop from 'lodash-es/noop'; +import once from 'lodash-es/once'; +import rest from 'lodash-es/rest'; + +import setImmediate from './internal/setImmediate'; + +export default function (tasks, concurrency, callback) { + if (typeof arguments[1] === 'function') { + // concurrency is optional, shift the args. + callback = concurrency; + concurrency = null; + } + callback = once(callback || noop); + var keys = okeys(tasks); + var remainingTasks = keys.length; + if (!remainingTasks) { + return callback(null); + } + if (!concurrency) { + concurrency = remainingTasks; + } + + var results = {}; + var runningTasks = 0; + + var listeners = []; + function addListener(fn) { + listeners.unshift(fn); + } + function removeListener(fn) { + var idx = indexOf(listeners, fn); + if (idx >= 0) listeners.splice(idx, 1); + } + function taskComplete() { + remainingTasks--; + arrayEach(listeners.slice(), function (fn) { + fn(); + }); + } + + addListener(function () { + if (!remainingTasks) { + callback(null, results); + } + }); + + arrayEach(keys, function (k) { + var task = isArray(tasks[k]) ? tasks[k]: [tasks[k]]; + var taskCallback = rest(function(err, args) { + runningTasks--; + if (args.length <= 1) { + args = args[0]; + } + if (err) { + var safeResults = {}; + forOwn(results, function(val, rkey) { + safeResults[rkey] = val; + }); + safeResults[k] = args; + callback(err, safeResults); + } + else { + results[k] = args; + setImmediate(taskComplete); + } + }); + var requires = task.slice(0, task.length - 1); + // prevent dead-locks + var len = requires.length; + var dep; + while (len--) { + if (!(dep = tasks[requires[len]])) { + throw new Error('Has inexistant dependency'); + } + if (isArray(dep) && indexOf(dep, k) >= 0) { + throw new Error('Has cyclic dependencies'); + } + } + function ready() { + return runningTasks < concurrency && !baseHas(results, k) && + arrayEvery(requires, function (x) { + return baseHas(results, x); + }); + } + if (ready()) { + runningTasks++; + task[task.length - 1](taskCallback, results); + } + else { + addListener(listener); + } + function listener() { + if (ready()) { + runningTasks++; + removeListener(listener); + task[task.length - 1](taskCallback, results); + } + } + }); +} diff --git a/build/es/cargo.js b/build/es/cargo.js new file mode 100644 index 0000000..b90ab0f --- /dev/null +++ b/build/es/cargo.js @@ -0,0 +1,7 @@ +'use strict'; + +import queue from './internal/queue'; + +export default function cargo(worker, payload) { + return queue(worker, 1, payload); +} diff --git a/build/es/compose.js b/build/es/compose.js new file mode 100644 index 0000000..9e92521 --- /dev/null +++ b/build/es/compose.js @@ -0,0 +1,9 @@ +'use strict'; + +import seq from './seq'; + +var reverse = Array.prototype.reverse; + +export default function compose(/* functions... */) { + return seq.apply(null, reverse.call(arguments)); +} diff --git a/build/es/concat.js b/build/es/concat.js new file mode 100644 index 0000000..af019a3 --- /dev/null +++ b/build/es/concat.js @@ -0,0 +1,6 @@ +'use strict'; + +import concat from './internal/concat'; +import doParallel from './internal/doParallel'; + +export default doParallel(concat); diff --git a/build/es/concatSeries.js b/build/es/concatSeries.js new file mode 100644 index 0000000..76f4043 --- /dev/null +++ b/build/es/concatSeries.js @@ -0,0 +1,6 @@ +'use strict'; + +import concat from './internal/concat'; +import doSeries from './internal/doSeries'; + +export default doSeries(concat); diff --git a/build/es/constant.js b/build/es/constant.js new file mode 100644 index 0000000..492d11b --- /dev/null +++ b/build/es/constant.js @@ -0,0 +1,10 @@ +'use strict'; + +import rest from 'lodash-es/rest'; + +export default rest(function(values) { + var args = [null].concat(values); + return function (cb) { + return cb.apply(this, args); + }; +}); diff --git a/build/es/detect.js b/build/es/detect.js new file mode 100644 index 0000000..19fffef --- /dev/null +++ b/build/es/detect.js @@ -0,0 +1,9 @@ +'use strict'; + +import identity from 'lodash-es/identity'; + +import createTester from './internal/createTester'; +import eachOf from './eachOf'; +import findGetResult from './internal/findGetResult'; + +export default createTester(eachOf, identity, findGetResult); diff --git a/build/es/detectLimit.js b/build/es/detectLimit.js new file mode 100644 index 0000000..0fc46db --- /dev/null +++ b/build/es/detectLimit.js @@ -0,0 +1,9 @@ +'use strict'; + +import identity from 'lodash-es/identity'; + +import createTester from './internal/createTester'; +import eachOfLimit from './eachOfLimit'; +import findGetResult from './internal/findGetResult'; + +export default createTester(eachOfLimit, identity, findGetResult); diff --git a/build/es/detectSeries.js b/build/es/detectSeries.js new file mode 100644 index 0000000..26f48ba --- /dev/null +++ b/build/es/detectSeries.js @@ -0,0 +1,9 @@ +'use strict'; + +import identity from 'lodash-es/identity'; + +import createTester from './internal/createTester'; +import eachOfSeries from './eachOfSeries'; +import findGetResult from './internal/findGetResult'; + +export default createTester(eachOfSeries, identity, findGetResult); diff --git a/build/es/dir.js b/build/es/dir.js new file mode 100644 index 0000000..049b416 --- /dev/null +++ b/build/es/dir.js @@ -0,0 +1,5 @@ +'use strict'; + +import consoleFunc from './internal/consoleFunc'; + +export default consoleFunc('dir'); diff --git a/build/es/doDuring.js b/build/es/doDuring.js new file mode 100644 index 0000000..c13e62b --- /dev/null +++ b/build/es/doDuring.js @@ -0,0 +1,12 @@ +'use strict'; + +import during from './during'; + +export default function doDuring(iterator, test, cb) { + var calls = 0; + + during(function(next) { + if (calls++ < 1) return next(null, true); + test.apply(this, arguments); + }, iterator, cb); +} diff --git a/build/es/doUntil.js b/build/es/doUntil.js new file mode 100644 index 0000000..3bc783f --- /dev/null +++ b/build/es/doUntil.js @@ -0,0 +1,9 @@ +'use strict'; + +import doWhilst from './doWhilst'; + +export default function doUntil(iterator, test, cb) { + return doWhilst(iterator, function() { + return !test.apply(this, arguments); + }, cb); +} diff --git a/build/es/doWhilst.js b/build/es/doWhilst.js new file mode 100644 index 0000000..b05d1d8 --- /dev/null +++ b/build/es/doWhilst.js @@ -0,0 +1,10 @@ +'use strict'; + +import whilst from './whilst'; + +export default function doWhilst(iterator, test, cb) { + var calls = 0; + return whilst(function() { + return ++calls <= 1 || test.apply(this, arguments); + }, iterator, cb); +} diff --git a/build/es/during.js b/build/es/during.js new file mode 100644 index 0000000..e9809cd --- /dev/null +++ b/build/es/during.js @@ -0,0 +1,25 @@ +'use strict'; + +import noop from 'lodash-es/noop'; +import rest from 'lodash-es/rest'; + +export default function during(test, iterator, cb) { + cb = cb || noop; + + var next = rest(function(err, args) { + if (err) { + cb(err); + } else { + args.push(check); + test.apply(this, args); + } + }); + + var check = function(err, truth) { + if (err) return cb(err); + if (!truth) return cb(null); + iterator(next); + }; + + test(check); +} diff --git a/build/es/each.js b/build/es/each.js new file mode 100644 index 0000000..384bb0a --- /dev/null +++ b/build/es/each.js @@ -0,0 +1,8 @@ +'use strict'; + +import eachOf from './eachOf'; +import withoutIndex from './internal/withoutIndex'; + +export default function each(arr, iterator, cb) { + return eachOf(arr, withoutIndex(iterator), cb); +} diff --git a/build/es/eachLimit.js b/build/es/eachLimit.js new file mode 100644 index 0000000..5009cc3 --- /dev/null +++ b/build/es/eachLimit.js @@ -0,0 +1,9 @@ +'use strict'; + +import eachOfLimit from './internal/eachOfLimit'; +import withoutIndex from './internal/withoutIndex'; + + +export default function eachLimit(arr, limit, iterator, cb) { + return eachOfLimit(limit)(arr, withoutIndex(iterator), cb); +} diff --git a/build/es/eachOf.js b/build/es/eachOf.js new file mode 100644 index 0000000..e06f2bb --- /dev/null +++ b/build/es/eachOf.js @@ -0,0 +1,34 @@ +'use strict'; + +import once from 'lodash-es/once'; +import noop from 'lodash-es/noop'; + +import keyIterator from './internal/keyIterator'; +import onlyOnce from './internal/onlyOnce'; + +export default function eachOf(object, iterator, callback) { + callback = once(callback || noop); + object = object || []; + + var iter = keyIterator(object); + var key, completed = 0; + + while ((key = iter()) != null) { + completed += 1; + iterator(object[key], key, onlyOnce(done)); + } + + if (completed === 0) callback(null); + + function done(err) { + completed--; + if (err) { + callback(err); + } + // Check key is null in case iterator isn't exhausted + // and done resolved synchronously. + else if (key === null && completed <= 0) { + callback(null); + } + } +} diff --git a/build/es/eachOfLimit.js b/build/es/eachOfLimit.js new file mode 100644 index 0000000..e381474 --- /dev/null +++ b/build/es/eachOfLimit.js @@ -0,0 +1,7 @@ +'use strict'; + +import _eachOfLimit from './internal/eachOfLimit'; + +export default function eachOfLimit(obj, limit, iterator, cb) { + _eachOfLimit(limit)(obj, iterator, cb); +} diff --git a/build/es/eachOfSeries.js b/build/es/eachOfSeries.js new file mode 100644 index 0000000..2456bbb --- /dev/null +++ b/build/es/eachOfSeries.js @@ -0,0 +1,40 @@ +'use strict'; + +import once from 'lodash-es/once'; +import noop from 'lodash-es/noop'; + +import keyIterator from './internal/keyIterator'; +import onlyOnce from './internal/onlyOnce'; +import setImmediate from './setImmediate'; + +export default function eachOfSeries(obj, iterator, callback) { + callback = once(callback || noop); + obj = obj || []; + var nextKey = keyIterator(obj); + var key = nextKey(); + + function iterate() { + var sync = true; + if (key === null) { + return callback(null); + } + iterator(obj[key], key, onlyOnce(function(err) { + if (err) { + callback(err); + } else { + key = nextKey(); + if (key === null) { + return callback(null); + } else { + if (sync) { + setImmediate(iterate); + } else { + iterate(); + } + } + } + })); + sync = false; + } + iterate(); +} diff --git a/build/es/eachSeries.js b/build/es/eachSeries.js new file mode 100644 index 0000000..fd08c04 --- /dev/null +++ b/build/es/eachSeries.js @@ -0,0 +1,8 @@ +'use strict'; + +import eachOfSeries from './eachOfSeries'; +import withoutIndex from './internal/withoutIndex'; + +export default function eachSeries(arr, iterator, cb) { + return eachOfSeries(arr, withoutIndex(iterator), cb); +} diff --git a/build/es/ensureAsync.js b/build/es/ensureAsync.js new file mode 100644 index 0000000..ba9affd --- /dev/null +++ b/build/es/ensureAsync.js @@ -0,0 +1,24 @@ +'use strict'; + +import rest from 'lodash-es/rest'; + +import setImmediate from './internal/setImmediate'; + +export default function ensureAsync(fn) { + return rest(function (args) { + var callback = args.pop(); + var sync = true; + args.push(function () { + var innerArgs = arguments; + if (sync) { + setImmediate(function () { + callback.apply(null, innerArgs); + }); + } else { + callback.apply(null, innerArgs); + } + }); + fn.apply(this, args); + sync = false; + }); +} diff --git a/build/es/every.js b/build/es/every.js new file mode 100644 index 0000000..7ee3713 --- /dev/null +++ b/build/es/every.js @@ -0,0 +1,7 @@ +'use strict'; + +import createTester from './internal/createTester'; +import eachOf from './eachOf'; +import notId from './internal/notId'; + +export default createTester(eachOf, notId, notId); diff --git a/build/es/everyLimit.js b/build/es/everyLimit.js new file mode 100644 index 0000000..4b3fc5f --- /dev/null +++ b/build/es/everyLimit.js @@ -0,0 +1,7 @@ +'use strict'; + +import createTester from './internal/createTester'; +import eachOfLimit from './eachOfLimit'; +import notId from './internal/notId'; + +export default createTester(eachOfLimit, notId, notId); diff --git a/build/es/filter.js b/build/es/filter.js new file mode 100644 index 0000000..36af2b1 --- /dev/null +++ b/build/es/filter.js @@ -0,0 +1,6 @@ +'use strict'; + +import filter from './internal/filter'; +import doParallel from './internal/doParallel'; + +export default doParallel(filter); diff --git a/build/es/filterLimit.js b/build/es/filterLimit.js new file mode 100644 index 0000000..8fe237f --- /dev/null +++ b/build/es/filterLimit.js @@ -0,0 +1,6 @@ +'use strict'; + +import filter from './internal/filter'; +import doParallelLimit from './internal/doParallelLimit'; + +export default doParallelLimit(filter); diff --git a/build/es/filterSeries.js b/build/es/filterSeries.js new file mode 100644 index 0000000..861ca8b --- /dev/null +++ b/build/es/filterSeries.js @@ -0,0 +1,6 @@ +'use strict'; + +import filter from './internal/filter'; +import doSeries from './internal/doSeries'; + +export default doSeries(filter); diff --git a/build/es/forever.js b/build/es/forever.js new file mode 100644 index 0000000..fca0684 --- /dev/null +++ b/build/es/forever.js @@ -0,0 +1,17 @@ +'use strict'; + +import noop from 'lodash-es/noop'; + +import onlyOnce from './internal/onlyOnce'; +import ensureAsync from './ensureAsync'; + +export default function forever(fn, cb) { + var done = onlyOnce(cb || noop); + var task = ensureAsync(fn); + + function next(err) { + if (err) return done(err); + task(next); + } + next(); +} diff --git a/build/es/index.js b/build/es/index.js new file mode 100644 index 0000000..a165909 --- /dev/null +++ b/build/es/index.js @@ -0,0 +1,228 @@ +'use strict'; + +import applyEach from './applyEach'; +import applyEachSeries from './applyEachSeries'; +import apply from './apply'; +import asyncify from './asyncify'; +import auto from './auto'; +import cargo from './cargo'; +import compose from './compose'; +import concat from './concat'; +import concatSeries from './concatSeries'; +import constant from './constant'; +import detect from './detect'; +import detectLimit from './detectLimit'; +import detectSeries from './detectSeries'; +import dir from './dir'; +import doDuring from './doDuring'; +import doUntil from './doUntil'; +import doWhilst from './doWhilst'; +import during from './during'; +import each from './each'; +import eachLimit from './eachLimit'; +import eachOf from './eachOf'; +import eachOfLimit from './eachOfLimit'; +import eachOfSeries from './eachOfSeries'; +import eachSeries from './eachSeries'; +import ensureAsync from './ensureAsync'; +import every from './every'; +import everyLimit from './everyLimit'; +import filter from './filter'; +import filterLimit from './filterLimit'; +import filterSeries from './filterSeries'; +import forever from './forever'; +import iterator from './iterator'; +import log from './log'; +import map from './map'; +import mapLimit from './mapLimit'; +import mapSeries from './mapSeries'; +import memoize from './memoize'; +import nextTick from './nextTick'; +import parallel from './parallel'; +import parallelLimit from './parallelLimit'; +import priorityQueue from './priorityQueue'; +import queue from './queue'; +import reduce from './reduce'; +import reduceRight from './reduceRight'; +import reject from './reject'; +import rejectLimit from './rejectLimit'; +import rejectSeries from './rejectSeries'; +import retry from './retry'; +import seq from './seq'; +import series from './series'; +import setImmediate from './setImmediate'; +import some from './some'; +import someLimit from './someLimit'; +import sortBy from './sortBy'; +import times from './times'; +import timesLimit from './timesLimit'; +import timesSeries from './timesSeries'; +import transform from './transform'; +import unmemoize from './unmemoize'; +import until from './until'; +import waterfall from './waterfall'; +import whilst from './whilst'; + +export default { + applyEach: applyEach, + applyEachSeries: applyEachSeries, + apply: apply, + asyncify: asyncify, + auto: auto, + cargo: cargo, + compose: compose, + concat: concat, + concatSeries: concatSeries, + constant: constant, + detect: detect, + detectLimit: detectLimit, + detectSeries: detectSeries, + dir: dir, + doDuring: doDuring, + doUntil: doUntil, + doWhilst: doWhilst, + during: during, + each: each, + eachLimit: eachLimit, + eachOf: eachOf, + eachOfLimit: eachOfLimit, + eachOfSeries: eachOfSeries, + eachSeries: eachSeries, + ensureAsync: ensureAsync, + every: every, + everyLimit: everyLimit, + filter: filter, + filterLimit: filterLimit, + filterSeries: filterSeries, + forever: forever, + iterator: iterator, + log: log, + map: map, + mapLimit: mapLimit, + mapSeries: mapSeries, + memoize: memoize, + nextTick: nextTick, + parallel: parallel, + parallelLimit: parallelLimit, + priorityQueue: priorityQueue, + queue: queue, + reduce: reduce, + reduceRight: reduceRight, + reject: reject, + rejectLimit: rejectLimit, + rejectSeries: rejectSeries, + retry: retry, + seq: seq, + series: series, + setImmediate: setImmediate, + some: some, + someLimit: someLimit, + sortBy: sortBy, + times: times, + timesLimit: timesLimit, + timesSeries: timesSeries, + transform: transform, + unmemoize: unmemoize, + until: until, + waterfall: waterfall, + whilst: whilst, + + // aliases + all: every, + any: some, + forEach: each, + forEachSeries: eachSeries, + forEachLimit: eachLimit, + forEachOf: eachOf, + forEachOfSeries: eachOfSeries, + forEachOfLimit: eachOfLimit, + inject: reduce, + foldl: reduce, + foldr: reduceRight, + select: filter, + selectLimit: filterLimit, + selectSeries: filterSeries, + wrapSync: asyncify +}; + +export { + applyEach as applyEach, + applyEachSeries as applyEachSeries, + apply as apply, + asyncify as asyncify, + auto as auto, + cargo as cargo, + compose as compose, + concat as concat, + concatSeries as concatSeries, + constant as constant, + detect as detect, + detectLimit as detectLimit, + detectSeries as detectSeries, + dir as dir, + doDuring as doDuring, + doUntil as doUntil, + doWhilst as doWhilst, + during as during, + each as each, + eachLimit as eachLimit, + eachOf as eachOf, + eachOfLimit as eachOfLimit, + eachOfSeries as eachOfSeries, + eachSeries as eachSeries, + ensureAsync as ensureAsync, + every as every, + everyLimit as everyLimit, + filter as filter, + filterLimit as filterLimit, + filterSeries as filterSeries, + forever as forever, + iterator as iterator, + log as log, + map as map, + mapLimit as mapLimit, + mapSeries as mapSeries, + memoize as memoize, + nextTick as nextTick, + parallel as parallel, + parallelLimit as parallelLimit, + priorityQueue as priorityQueue, + queue as queue, + reduce as reduce, + reduceRight as reduceRight, + reject as reject, + rejectLimit as rejectLimit, + rejectSeries as rejectSeries, + retry as retry, + seq as seq, + series as series, + setImmediate as setImmediate, + some as some, + someLimit as someLimit, + sortBy as sortBy, + times as times, + timesLimit as timesLimit, + timesSeries as timesSeries, + transform as transform, + unmemoize as unmemoize, + until as until, + waterfall as waterfall, + whilst as whilst, + + // Aliases + every as all, + some as any, + each as forEach, + eachSeries as forEachSeries, + eachLimit as forEachLimit, + eachOf as forEachOf, + eachOfSeries as forEachOfSeries, + eachOfLimit as forEachOfLimit, + reduce as inject, + reduce as foldl, + reduceRight as foldr, + filter as select, + filterLimit as selectLimit, + filterSeries as selectSeries, + asyncify as wrapSync +}; diff --git a/build/es/internal/applyEach.js b/build/es/internal/applyEach.js new file mode 100644 index 0000000..1467363 --- /dev/null +++ b/build/es/internal/applyEach.js @@ -0,0 +1,22 @@ +'use strict'; + +import rest from 'lodash-es/rest'; + +export default function applyEach(eachfn) { + return rest(function(fns, args) { + var go = rest(function(args) { + var that = this; + var callback = args.pop(); + return eachfn(fns, function (fn, _, cb) { + fn.apply(that, args.concat([cb])); + }, + callback); + }); + if (args.length) { + return go.apply(this, args); + } + else { + return go; + } + }); +} diff --git a/build/es/internal/concat.js b/build/es/internal/concat.js new file mode 100644 index 0000000..482ad3a --- /dev/null +++ b/build/es/internal/concat.js @@ -0,0 +1,13 @@ +'use strict'; + +export default function concat(eachfn, arr, fn, callback) { + var result = []; + eachfn(arr, function (x, index, cb) { + fn(x, function (err, y) { + result = result.concat(y || []); + cb(err); + }); + }, function (err) { + callback(err, result); + }); +} diff --git a/build/es/internal/consoleFunc.js b/build/es/internal/consoleFunc.js new file mode 100644 index 0000000..7796d87 --- /dev/null +++ b/build/es/internal/consoleFunc.js @@ -0,0 +1,23 @@ +'use strict'; + +import arrayEach from 'lodash-es/internal/arrayEach'; +import rest from 'lodash-es/rest'; + +export default function consoleFunc(name) { + return rest(function (fn, args) { + fn.apply(null, args.concat([rest(function (err, args) { + if (typeof console === 'object') { + if (err) { + if (console.error) { + console.error(err); + } + } + else if (console[name]) { + arrayEach(args, function (x) { + console[name](x); + }); + } + } + })])); + }); +} diff --git a/build/es/internal/createTester.js b/build/es/internal/createTester.js new file mode 100644 index 0000000..1bf2e89 --- /dev/null +++ b/build/es/internal/createTester.js @@ -0,0 +1,26 @@ +'use strict'; + +export default function _createTester(eachfn, check, getResult) { + return function(arr, limit, iterator, cb) { + function done() { + if (cb) cb(getResult(false, void 0)); + } + function iteratee(x, _, callback) { + if (!cb) return callback(); + iterator(x, function (v) { + if (cb && check(v)) { + cb(getResult(true, x)); + cb = iterator = false; + } + callback(); + }); + } + if (arguments.length > 3) { + eachfn(arr, limit, iteratee, done); + } else { + cb = iterator; + iterator = limit; + eachfn(arr, iteratee, done); + } + }; +} diff --git a/build/es/internal/doParallel.js b/build/es/internal/doParallel.js new file mode 100644 index 0000000..19c90fc --- /dev/null +++ b/build/es/internal/doParallel.js @@ -0,0 +1,9 @@ +'use strict'; + +import eachOf from '../eachOf'; + +export default function doParallel(fn) { + return function (obj, iterator, callback) { + return fn(eachOf, obj, iterator, callback); + }; +} diff --git a/build/es/internal/doParallelLimit.js b/build/es/internal/doParallelLimit.js new file mode 100644 index 0000000..0c3bcf7 --- /dev/null +++ b/build/es/internal/doParallelLimit.js @@ -0,0 +1,9 @@ +'use strict'; + +import eachOfLimit from './eachOfLimit'; + +export default function doParallelLimit(fn) { + return function (obj, limit, iterator, callback) { + return fn(eachOfLimit(limit), obj, iterator, callback); + }; +} diff --git a/build/es/internal/doSeries.js b/build/es/internal/doSeries.js new file mode 100644 index 0000000..c7f1d99 --- /dev/null +++ b/build/es/internal/doSeries.js @@ -0,0 +1,9 @@ +'use strict'; + +import eachOfSeries from '../eachOfSeries'; + +export default function doSeries(fn) { + return function (obj, iterator, callback) { + return fn(eachOfSeries, obj, iterator, callback); + }; +} diff --git a/build/es/internal/eachOfLimit.js b/build/es/internal/eachOfLimit.js new file mode 100644 index 0000000..5235278 --- /dev/null +++ b/build/es/internal/eachOfLimit.js @@ -0,0 +1,49 @@ +'use strict'; + +import noop from 'lodash-es/noop'; +import once from 'lodash-es/once'; + +import keyIterator from './keyIterator'; +import onlyOnce from './onlyOnce'; + +export default function _eachOfLimit(limit) { + return function (obj, iterator, callback) { + callback = once(callback || noop); + obj = obj || []; + var nextKey = keyIterator(obj); + if (limit <= 0) { + return callback(null); + } + var done = false; + var running = 0; + var errored = false; + + (function replenish () { + if (done && running <= 0) { + return callback(null); + } + + while (running < limit && !errored) { + var key = nextKey(); + if (key === null) { + done = true; + if (running <= 0) { + callback(null); + } + return; + } + running += 1; + iterator(obj[key], key, onlyOnce(function (err) { + running -= 1; + if (err) { + callback(err); + errored = true; + } + else { + replenish(); + } + })); + } + })(); + }; +} diff --git a/build/es/internal/filter.js b/build/es/internal/filter.js new file mode 100644 index 0000000..f58eb52 --- /dev/null +++ b/build/es/internal/filter.js @@ -0,0 +1,20 @@ +'use strict'; + +import arrayMap from 'lodash-es/internal/arrayMap'; +import property from 'lodash-es/internal/baseProperty'; + +export default function _filter(eachfn, arr, iterator, callback) { + var results = []; + eachfn(arr, function (x, index, callback) { + iterator(x, function (v) { + if (v) { + results.push({index: index, value: x}); + } + callback(); + }); + }, function () { + callback(arrayMap(results.sort(function (a, b) { + return a.index - b.index; + }), property('value'))); + }); +} diff --git a/build/es/internal/findGetResult.js b/build/es/internal/findGetResult.js new file mode 100644 index 0000000..3aeb07d --- /dev/null +++ b/build/es/internal/findGetResult.js @@ -0,0 +1,5 @@ +'use strict'; + +export default function _findGetResult(v, x) { + return x; +} diff --git a/build/es/internal/keyIterator.js b/build/es/internal/keyIterator.js new file mode 100644 index 0000000..9f12beb --- /dev/null +++ b/build/es/internal/keyIterator.js @@ -0,0 +1,23 @@ +'use strict'; + +import isArrayLike from 'lodash-es/isArrayLike'; +import keys from 'lodash-es/keys'; + +export default function keyIterator(coll) { + var i = -1; + var len; + if (isArrayLike(coll)) { + len = coll.length; + return function next() { + i++; + return i < len ? i : null; + }; + } else { + var okeys = keys(coll); + len = okeys.length; + return function next() { + i++; + return i < len ? okeys[i] : null; + }; + } +} diff --git a/build/es/internal/map.js b/build/es/internal/map.js new file mode 100644 index 0000000..5057f49 --- /dev/null +++ b/build/es/internal/map.js @@ -0,0 +1,19 @@ +'use strict'; + +import isArrayLike from 'lodash-es/isArrayLike'; +import noop from 'lodash-es/noop'; +import once from 'lodash-es/once'; + +export default function _asyncMap(eachfn, arr, iterator, callback) { + callback = once(callback || noop); + arr = arr || []; + var results = isArrayLike(arr) ? [] : {}; + eachfn(arr, function (value, index, callback) { + iterator(value, function (err, v) { + results[index] = v; + callback(err); + }); + }, function (err) { + callback(err, results); + }); +} diff --git a/build/es/internal/notId.js b/build/es/internal/notId.js new file mode 100644 index 0000000..d936aab --- /dev/null +++ b/build/es/internal/notId.js @@ -0,0 +1,5 @@ +'use strict'; + +export default function notId(v) { + return !v; +} diff --git a/build/es/internal/onlyOnce.js b/build/es/internal/onlyOnce.js new file mode 100644 index 0000000..f4241c8 --- /dev/null +++ b/build/es/internal/onlyOnce.js @@ -0,0 +1,9 @@ +'use strict'; + +export default function onlyOnce(fn) { + return function() { + if (fn === null) throw new Error("Callback was already called."); + fn.apply(this, arguments); + fn = null; + }; +} diff --git a/build/es/internal/parallel.js b/build/es/internal/parallel.js new file mode 100644 index 0000000..b532908 --- /dev/null +++ b/build/es/internal/parallel.js @@ -0,0 +1,22 @@ +'use strict'; + +import noop from 'lodash-es/noop'; +import isArrayLike from 'lodash-es/isArrayLike'; +import rest from 'lodash-es/rest'; + +export default function _parallel(eachfn, tasks, callback) { + callback = callback || noop; + var results = isArrayLike(tasks) ? [] : {}; + + eachfn(tasks, function (task, key, callback) { + task(rest(function (err, args) { + if (args.length <= 1) { + args = args[0]; + } + results[key] = args; + callback(err); + })); + }, function (err) { + callback(err, results); + }); +} diff --git a/build/es/internal/queue.js b/build/es/internal/queue.js new file mode 100644 index 0000000..2e291e3 --- /dev/null +++ b/build/es/internal/queue.js @@ -0,0 +1,140 @@ +'use strict'; + +import arrayEach from 'lodash-es/internal/arrayEach'; +import arrayMap from 'lodash-es/internal/arrayMap'; +import isArray from 'lodash-es/isArray'; +import noop from 'lodash-es/noop'; +import property from 'lodash-es/internal/baseProperty'; + +import onlyOnce from './onlyOnce'; +import setImmediate from './setImmediate'; + +export default function queue(worker, concurrency, payload) { + if (concurrency == null) { + concurrency = 1; + } + else if(concurrency === 0) { + throw new Error('Concurrency must not be zero'); + } + function _insert(q, data, pos, callback) { + if (callback != null && typeof callback !== 'function') { + throw new Error('task callback must be a function'); + } + q.started = true; + if (!isArray(data)) { + data = [data]; + } + if(data.length === 0 && q.idle()) { + // call drain immediately if there are no tasks + return setImmediate(function() { + q.drain(); + }); + } + arrayEach(data, function(task) { + var item = { + data: task, + callback: callback || noop + }; + + if (pos) { + q.tasks.unshift(item); + } else { + q.tasks.push(item); + } + + if (q.tasks.length === q.concurrency) { + q.saturated(); + } + }); + setImmediate(q.process); + } + function _next(q, tasks) { + return function(){ + workers -= 1; + + var removed = false; + var args = arguments; + arrayEach(tasks, function (task) { + arrayEach(workersList, function (worker, index) { + if (worker === task && !removed) { + workersList.splice(index, 1); + removed = true; + } + }); + + task.callback.apply(task, args); + }); + if (q.tasks.length + workers === 0) { + q.drain(); + } + q.process(); + }; + } + + var workers = 0; + var workersList = []; + var q = { + tasks: [], + concurrency: concurrency, + payload: payload, + saturated: noop, + empty: noop, + drain: noop, + started: false, + paused: false, + push: function (data, callback) { + _insert(q, data, false, callback); + }, + kill: function () { + q.drain = noop; + q.tasks = []; + }, + unshift: function (data, callback) { + _insert(q, data, true, callback); + }, + process: function () { + while(!q.paused && workers < q.concurrency && q.tasks.length){ + + var tasks = q.payload ? + q.tasks.splice(0, q.payload) : + q.tasks.splice(0, q.tasks.length); + + var data = arrayMap(tasks, property('data')); + + if (q.tasks.length === 0) { + q.empty(); + } + workers += 1; + workersList.push(tasks[0]); + var cb = onlyOnce(_next(q, tasks)); + worker(data, cb); + } + }, + length: function () { + return q.tasks.length; + }, + running: function () { + return workers; + }, + workersList: function () { + return workersList; + }, + idle: function() { + return q.tasks.length + workers === 0; + }, + pause: function () { + q.paused = true; + }, + resume: function () { + if (q.paused === false) { return; } + q.paused = false; + var resumeCount = Math.min(q.concurrency, q.tasks.length); + // Need to call q.process once per concurrent + // worker to preserve full concurrency after pause + for (var w = 1; w <= resumeCount; w++) { + setImmediate(q.process); + } + } + }; + return q; +} diff --git a/build/es/internal/reject.js b/build/es/internal/reject.js new file mode 100644 index 0000000..8b1bf0d --- /dev/null +++ b/build/es/internal/reject.js @@ -0,0 +1,11 @@ +'use strict'; + +import filter from './filter'; + +export default function reject(eachfn, arr, iterator, callback) { + filter(eachfn, arr, function(value, cb) { + iterator(value, function(v) { + cb(!v); + }); + }, callback); +} diff --git a/build/es/internal/setImmediate.js b/build/es/internal/setImmediate.js new file mode 100644 index 0000000..c02ad71 --- /dev/null +++ b/build/es/internal/setImmediate.js @@ -0,0 +1,19 @@ +'use strict'; + +var _setImmediate = typeof setImmediate === 'function' && setImmediate; + +var _delay; +if (_setImmediate) { + _delay = function(fn) { + // not a direct alias for IE10 compatibility + _setImmediate(fn); + }; +} else if (typeof process === 'object' && typeof process.nextTick === 'function') { + _delay = process.nextTick; +} else { + _delay = function(fn) { + setTimeout(fn, 0); + }; +} + +export default _delay; diff --git a/build/es/internal/withoutIndex.js b/build/es/internal/withoutIndex.js new file mode 100644 index 0000000..f163ff3 --- /dev/null +++ b/build/es/internal/withoutIndex.js @@ -0,0 +1,7 @@ +'use strict'; + +export default function _withoutIndex(iterator) { + return function (value, index, callback) { + return iterator(value, callback); + }; +} diff --git a/build/es/iterator.js b/build/es/iterator.js new file mode 100644 index 0000000..568171a --- /dev/null +++ b/build/es/iterator.js @@ -0,0 +1,17 @@ +'use strict'; + +export default function(tasks) { + function makeCallback(index) { + function fn() { + if (tasks.length) { + tasks[index].apply(null, arguments); + } + return fn.next(); + } + fn.next = function() { + return (index < tasks.length - 1) ? makeCallback(index + 1) : null; + }; + return fn; + } + return makeCallback(0); +} diff --git a/build/es/log.js b/build/es/log.js new file mode 100644 index 0000000..b581264 --- /dev/null +++ b/build/es/log.js @@ -0,0 +1,5 @@ +'use strict'; + +import consoleFunc from './internal/consoleFunc'; + +export default consoleFunc('log'); diff --git a/build/es/map.js b/build/es/map.js new file mode 100644 index 0000000..2a8449c --- /dev/null +++ b/build/es/map.js @@ -0,0 +1,6 @@ +'use strict'; + +import doParallel from './internal/doParallel'; +import map from './internal/map'; + +export default doParallel(map); diff --git a/build/es/mapLimit.js b/build/es/mapLimit.js new file mode 100644 index 0000000..642b4c6 --- /dev/null +++ b/build/es/mapLimit.js @@ -0,0 +1,6 @@ +'use strict'; + +import doParallelLimit from './internal/doParallelLimit'; +import map from './internal/map'; + +export default doParallelLimit(map); diff --git a/build/es/mapSeries.js b/build/es/mapSeries.js new file mode 100644 index 0000000..bfcdaa2 --- /dev/null +++ b/build/es/mapSeries.js @@ -0,0 +1,6 @@ +'use strict'; + +import map from './internal/map'; +import doSeries from './internal/doSeries'; + +export default doSeries(map); diff --git a/build/es/memoize.js b/build/es/memoize.js new file mode 100644 index 0000000..184f0d6 --- /dev/null +++ b/build/es/memoize.js @@ -0,0 +1,36 @@ +'use strict'; + +import identity from 'lodash-es/identity'; +import rest from 'lodash-es/rest'; + +import setImmediate from './internal/setImmediate'; + +export default function memoize(fn, hasher) { + var memo = {}; + var queues = {}; + hasher = hasher || identity; + var memoized = rest(function memoized(args) { + var callback = args.pop(); + var key = hasher.apply(null, args); + if (key in memo) { + setImmediate(function() { + callback.apply(null, memo[key]); + }); + } else if (key in queues) { + queues[key].push(callback); + } else { + queues[key] = [callback]; + fn.apply(null, args.concat([rest(function(args) { + memo[key] = args; + var q = queues[key]; + delete queues[key]; + for (var i = 0, l = q.length; i < l; i++) { + q[i].apply(null, args); + } + })])); + } + }); + memoized.memo = memo; + memoized.unmemoized = fn; + return memoized; +} diff --git a/build/es/nextTick.js b/build/es/nextTick.js new file mode 100644 index 0000000..b61a8b4 --- /dev/null +++ b/build/es/nextTick.js @@ -0,0 +1,7 @@ +'use strict'; + +import setImmediate from './internal/setImmediate'; + +var nexTick = typeof process === 'object' && typeof process.nextTick === 'function' ? process.nextTick : setImmediate; + +export default nexTick; diff --git a/build/es/parallel.js b/build/es/parallel.js new file mode 100644 index 0000000..d3eec16 --- /dev/null +++ b/build/es/parallel.js @@ -0,0 +1,8 @@ +'use strict'; + +import _parallel from './internal/parallel'; +import eachOf from './eachOf'; + +export default function parallel(tasks, cb) { + return _parallel(eachOf, tasks, cb); +} diff --git a/build/es/parallelLimit.js b/build/es/parallelLimit.js new file mode 100644 index 0000000..7e66bed --- /dev/null +++ b/build/es/parallelLimit.js @@ -0,0 +1,8 @@ +'use strict'; + +import eachOfLimit from './internal/eachOfLimit'; +import parallel from './internal/parallel'; + +export default function parallelLimit(tasks, limit, cb) { + return parallel(eachOfLimit(limit), tasks, cb); +} diff --git a/build/es/priorityQueue.js b/build/es/priorityQueue.js new file mode 100644 index 0000000..9f9d3a0 --- /dev/null +++ b/build/es/priorityQueue.js @@ -0,0 +1,72 @@ +'use strict'; + +import arrayEach from 'lodash-es/internal/arrayEach'; +import isArray from 'lodash-es/isArray'; +import noop from 'lodash-es/noop'; + +import setImmediate from './setImmediate'; + +import queue from './queue'; + +export default function(worker, concurrency) { + function _compareTasks(a, b) { + return a.priority - b.priority; + } + + function _binarySearch(sequence, item, compare) { + var beg = -1, + end = sequence.length - 1; + while (beg < end) { + var mid = beg + ((end - beg + 1) >>> 1); + if (compare(item, sequence[mid]) >= 0) { + beg = mid; + } else { + end = mid - 1; + } + } + return beg; + } + + function _insert(q, data, priority, callback) { + if (callback != null && typeof callback !== 'function') { + throw new Error('task callback must be a function'); + } + q.started = true; + if (!isArray(data)) { + data = [data]; + } + if (data.length === 0) { + // call drain immediately if there are no tasks + return setImmediate(function() { + q.drain(); + }); + } + arrayEach(data, function(task) { + var item = { + data: task, + priority: priority, + callback: typeof callback === 'function' ? callback : noop + }; + + q.tasks.splice(_binarySearch(q.tasks, item, _compareTasks) + 1, 0, item); + + if (q.tasks.length === q.concurrency) { + q.saturated(); + } + setImmediate(q.process); + }); + } + + // Start with a normal queue + var q = queue(worker, concurrency); + + // Override push to accept second parameter representing priority + q.push = function(data, priority, callback) { + _insert(q, data, priority, callback); + }; + + // Remove unshift function + delete q.unshift; + + return q; +} diff --git a/build/es/queue.js b/build/es/queue.js new file mode 100644 index 0000000..de2ac93 --- /dev/null +++ b/build/es/queue.js @@ -0,0 +1,9 @@ +'use strict'; + +import queue from './internal/queue'; + +export default function (worker, concurrency) { + return queue(function (items, cb) { + worker(items[0], cb); + }, concurrency, 1); +} diff --git a/build/es/reduce.js b/build/es/reduce.js new file mode 100644 index 0000000..51b736a --- /dev/null +++ b/build/es/reduce.js @@ -0,0 +1,14 @@ +'use strict'; + +import eachOfSeries from './eachOfSeries'; + +export default function reduce(arr, memo, iterator, cb) { + eachOfSeries(arr, function(x, i, cb) { + iterator(memo, x, function(err, v) { + memo = v; + cb(err); + }); + }, function(err) { + cb(err, memo); + }); +} diff --git a/build/es/reduceRight.js b/build/es/reduceRight.js new file mode 100644 index 0000000..730e320 --- /dev/null +++ b/build/es/reduceRight.js @@ -0,0 +1,10 @@ +'use strict'; + +import reduce from './reduce'; + +var slice = Array.prototype.slice; + +export default function reduceRight (arr, memo, iterator, cb) { + var reversed = slice.call(arr).reverse(); + reduce(reversed, memo, iterator, cb); +} diff --git a/build/es/reject.js b/build/es/reject.js new file mode 100644 index 0000000..fb5b87f --- /dev/null +++ b/build/es/reject.js @@ -0,0 +1,6 @@ +'use strict'; + +import reject from './internal/reject'; +import doParallel from './internal/doParallel'; + +export default doParallel(reject); diff --git a/build/es/rejectLimit.js b/build/es/rejectLimit.js new file mode 100644 index 0000000..7cefed6 --- /dev/null +++ b/build/es/rejectLimit.js @@ -0,0 +1,6 @@ +'use strict'; + +import reject from './internal/reject'; +import doParallelLimit from './internal/doParallelLimit'; + +export default doParallelLimit(reject); diff --git a/build/es/rejectSeries.js b/build/es/rejectSeries.js new file mode 100644 index 0000000..e02adea --- /dev/null +++ b/build/es/rejectSeries.js @@ -0,0 +1,6 @@ +'use strict'; + +import reject from './internal/reject'; +import doSeries from './internal/doSeries'; + +export default doSeries(reject); diff --git a/build/es/retry.js b/build/es/retry.js new file mode 100644 index 0000000..506a424 --- /dev/null +++ b/build/es/retry.js @@ -0,0 +1,77 @@ +'use strict'; + +import series from './series'; + +export default function retry(times, task, callback) { + var DEFAULT_TIMES = 5; + var DEFAULT_INTERVAL = 0; + + var attempts = []; + + var opts = { + times: DEFAULT_TIMES, + interval: DEFAULT_INTERVAL + }; + + function parseTimes(acc, t) { + if (typeof t === 'number') { + acc.times = parseInt(t, 10) || DEFAULT_TIMES; + } else if (typeof t === 'object') { + acc.times = parseInt(t.times, 10) || DEFAULT_TIMES; + acc.interval = parseInt(t.interval, 10) || DEFAULT_INTERVAL; + } else { + throw new Error('Unsupported argument type for \'times\': ' + typeof t); + } + } + + var length = arguments.length; + if (length < 1 || length > 3) { + throw new Error('Invalid arguments - must be either (task), (task, callback), (times, task) or (times, task, callback)'); + } else if (length <= 2 && typeof times === 'function') { + callback = task; + task = times; + } + if (typeof times !== 'function') { + parseTimes(opts, times); + } + opts.callback = callback; + opts.task = task; + + function wrappedTask(wrappedCallback, wrappedResults) { + function retryAttempt(task, finalAttempt) { + return function(seriesCallback) { + task(function(err, result) { + seriesCallback(!err || finalAttempt, { + err: err, + result: result + }); + }, wrappedResults); + }; + } + + function retryInterval(interval) { + return function(seriesCallback) { + setTimeout(function() { + seriesCallback(null); + }, interval); + }; + } + + while (opts.times) { + + var finalAttempt = !(opts.times -= 1); + attempts.push(retryAttempt(opts.task, finalAttempt)); + if (!finalAttempt && opts.interval > 0) { + attempts.push(retryInterval(opts.interval)); + } + } + + series(attempts, function(done, data) { + data = data[data.length - 1]; + (wrappedCallback || opts.callback)(data.err, data.result); + }); + } + + // If a callback is passed, run this as a controll flow + return opts.callback ? wrappedTask() : wrappedTask; +} diff --git a/build/es/seq.js b/build/es/seq.js new file mode 100644 index 0000000..c9e02c1 --- /dev/null +++ b/build/es/seq.js @@ -0,0 +1,28 @@ +'use strict'; + +import noop from 'lodash-es/noop'; +import rest from 'lodash-es/rest'; +import reduce from './reduce'; + +export default function seq( /* functions... */ ) { + var fns = arguments; + return rest(function(args) { + var that = this; + + var cb = args[args.length - 1]; + if (typeof cb == 'function') { + args.pop(); + } else { + cb = noop; + } + + reduce(fns, args, function(newargs, fn, cb) { + fn.apply(that, newargs.concat([rest(function(err, nextargs) { + cb(err, nextargs); + })])); + }, + function(err, results) { + cb.apply(that, [err].concat(results)); + }); + }); +} diff --git a/build/es/series.js b/build/es/series.js new file mode 100644 index 0000000..bd8e15d --- /dev/null +++ b/build/es/series.js @@ -0,0 +1,8 @@ +'use strict'; + +import parallel from './internal/parallel'; +import eachOfSeries from './eachOfSeries'; + +export default function series(tasks, cb) { + return parallel(eachOfSeries, tasks, cb); +} diff --git a/build/es/setImmediate.js b/build/es/setImmediate.js new file mode 100644 index 0000000..05d9555 --- /dev/null +++ b/build/es/setImmediate.js @@ -0,0 +1,5 @@ +'use strict'; + +import setImmediate from './internal/setImmediate'; + +export default setImmediate; diff --git a/build/es/some.js b/build/es/some.js new file mode 100644 index 0000000..46532b7 --- /dev/null +++ b/build/es/some.js @@ -0,0 +1,8 @@ +'use strict'; + +import identity from 'lodash-es/identity'; + +import createTester from './internal/createTester'; +import eachOf from './eachOf'; + +export default createTester(eachOf, Boolean, identity); diff --git a/build/es/someLimit.js b/build/es/someLimit.js new file mode 100644 index 0000000..6c17067 --- /dev/null +++ b/build/es/someLimit.js @@ -0,0 +1,7 @@ +'use strict'; + +import createTester from './internal/createTester'; +import eachOfLimit from './eachOfLimit'; +import identity from 'lodash-es/identity'; + +export default createTester(eachOfLimit, Boolean, identity); diff --git a/build/es/sortBy.js b/build/es/sortBy.js new file mode 100644 index 0000000..b4c8b8e --- /dev/null +++ b/build/es/sortBy.js @@ -0,0 +1,23 @@ +'use strict'; + +import arrayMap from 'lodash-es/internal/arrayMap'; +import property from 'lodash-es/internal/baseProperty'; + +import map from './map'; + +export default function sortBy (arr, iterator, cb) { + map(arr, function (x, cb) { + iterator(x, function (err, criteria) { + if (err) return cb(err); + cb(null, {value: x, criteria: criteria}); + }); + }, function (err, results) { + if (err) return cb(err); + cb(null, arrayMap(results.sort(comparator), property('value'))); + }); + + function comparator(left, right) { + var a = left.criteria, b = right.criteria; + return a < b ? -1 : a > b ? 1 : 0; + } +} diff --git a/build/es/times.js b/build/es/times.js new file mode 100644 index 0000000..da2b31f --- /dev/null +++ b/build/es/times.js @@ -0,0 +1,8 @@ +'use strict'; + +import map from './map'; +import range from 'lodash-es/internal/baseRange'; + +export default function (count, iterator, callback) { + map(range(0, count, 1), iterator, callback); +} diff --git a/build/es/timesLimit.js b/build/es/timesLimit.js new file mode 100644 index 0000000..9c2feca --- /dev/null +++ b/build/es/timesLimit.js @@ -0,0 +1,8 @@ +'use strict'; + +import mapLimit from './mapLimit'; +import range from 'lodash-es/internal/baseRange'; + +export default function timeLimit(count, limit, iterator, cb) { + return mapLimit(range(0, count, 1), limit, iterator, cb); +} diff --git a/build/es/timesSeries.js b/build/es/timesSeries.js new file mode 100644 index 0000000..ebcb345 --- /dev/null +++ b/build/es/timesSeries.js @@ -0,0 +1,8 @@ +'use strict'; + +import mapSeries from './mapSeries'; +import range from 'lodash-es/internal/baseRange'; + +export default function (count, iterator, callback) { + mapSeries(range(0, count, 1), iterator, callback); +} diff --git a/build/es/transform.js b/build/es/transform.js new file mode 100644 index 0000000..7b80fca --- /dev/null +++ b/build/es/transform.js @@ -0,0 +1,19 @@ +'use strict'; + +import isArray from 'lodash-es/isArray'; + +import eachOf from './eachOf'; + +export default function transform (arr, memo, iterator, callback) { + if (arguments.length === 3) { + callback = iterator; + iterator = memo; + memo = isArray(arr) ? [] : {}; + } + + eachOf(arr, function(v, k, cb) { + iterator(memo, v, k, cb); + }, function(err) { + callback(err, memo); + }); +} diff --git a/build/es/unmemoize.js b/build/es/unmemoize.js new file mode 100644 index 0000000..d652e7b --- /dev/null +++ b/build/es/unmemoize.js @@ -0,0 +1,7 @@ +'use strict'; + +export default function unmemoize(fn) { + return function () { + return (fn.unmemoized || fn).apply(null, arguments); + }; +} diff --git a/build/es/until.js b/build/es/until.js new file mode 100644 index 0000000..f9ed2fd --- /dev/null +++ b/build/es/until.js @@ -0,0 +1,9 @@ +'use strict'; + +import whilst from './whilst'; + +export default function until(test, iterator, cb) { + return whilst(function() { + return !test.apply(this, arguments); + }, iterator, cb); +} diff --git a/build/es/waterfall.js b/build/es/waterfall.js new file mode 100644 index 0000000..c629bcf --- /dev/null +++ b/build/es/waterfall.js @@ -0,0 +1,32 @@ +'use strict'; + +import isArray from 'lodash-es/isArray'; +import noop from 'lodash-es/noop'; +import once from 'lodash-es/once'; +import rest from 'lodash-es/rest'; + +import ensureAsync from './ensureAsync'; +import iterator from './iterator'; + +export default function(tasks, cb) { + cb = once(cb || noop); + if (!isArray(tasks)) return cb(new Error('First argument to waterfall must be an array of functions')); + if (!tasks.length) return cb(); + + function wrapIterator(iterator) { + return rest(function(err, args) { + if (err) { + cb.apply(null, [err].concat(args)); + } else { + var next = iterator.next(); + if (next) { + args.push(wrapIterator(next)); + } else { + args.push(cb); + } + ensureAsync(iterator).apply(null, args); + } + }); + } + wrapIterator(iterator(tasks))(); +} diff --git a/build/es/whilst.js b/build/es/whilst.js new file mode 100644 index 0000000..2f5c2ef --- /dev/null +++ b/build/es/whilst.js @@ -0,0 +1,15 @@ +'use strict'; + +import noop from 'lodash-es/noop'; +import rest from 'lodash-es/rest'; + +export default function whilst(test, iterator, cb) { + cb = cb || noop; + if (!test()) return cb(null); + var next = rest(function(err, args) { + if (err) return cb(err); + if (test.apply(this, args)) return iterator(next); + cb.apply(null, [null].concat(args)); + }); + iterator(next); +} |