Asynchronous Programming Library

Installation

$ npm install metasync

Asynchronous functions composition

metasync(fns)(data, done)

fns - array of callback-last functions, callback contranct err-first
data - input data (optional)
done - err-first callback
Returns: composed callback-last / err-first function

const composed = metasync([f1, f2, f3, [[f4, f5, [f6, f7], f8]], f9]);

Array of functions gives sequential execution: [f1, f2, f3]
Double brackets array of functions gives parallel execution: [[f1, f2, f3]]

Example:

const metasync = require('metasync');
const fs = require('fs');

// Data collector (collect keys by count)
const dc = metasync.collect(4);

dc.pick('user', { name: 'Marcus Aurelius' });
fs.readFile('HISTORY.md', (err, data) => dc.collect('history', err, data));
dc.take('readme', fs.readFile, 'README.md');
setTimeout(() => dc.pick('timer', { date: new Date() }), 1000);

// Key collector (collect certain keys by names)
const kc = metasync
  .collect(['user', 'history', 'readme', 'timer'])
  .timeout(2000)
  .distinct()
  .done((err, data) => console.log(data));

kc.pick('user', { name: 'Marcus Aurelius' });
kc.take('history', fs.readFile, 'HISTORY.md');
kc.take('readme', fs.readFile, 'README.md');
setTimeout(() => kc.pick('timer', { date: new Date() }), 1000);

API

callbackify(fn)

fn: <Function> promise-returning function

Returns: <Function>

Convert Promise-returning to callback-last / error-first contract

asyncify(fn)

fn: <Function> regular synchronous function

Returns: <Function> with contract: callback-last / error-first

Convert sync function to callback-last / error-first contract

promiseToCallbackLast(promise, callback)

promise: <Promise>
callback: <Function>

Convert Promise to callback-last

promisify(fn)

fn: <Function> callback-last function

Returns: <Function> Promise-returning function

Convert async function to Promise-returning function

promisifySync(fn)

fn: <Function> regular synchronous function

Returns: <Function> Promise-returning function

Convert sync function to Promise object

map(items, fn, done)

items: <Array> incoming
fn: <Function> to be executed for each value in the array
- current: <any> current element being processed in the array
- callback: <Function>
  - err: <Error>|<null>
  - value: <any>
done: <Function> on done
- err: <Error>|<null>
- result: <Array>

Asynchronous map (iterate parallel)

filter(items, fn, done)

items: <Array> incoming
fn: <Function> to be executed for each value in the array
- value: <any> item from items array
- callback: <Function>
  - err: <Error>|<null>
  - accepted: <boolean>
done: <Function> on done
- err: <Error>|<null>
- result: <Array>

Asynchrous filter (iterate parallel)

Example:

metasync.filter(
  ['data', 'to', 'filter'],
  (item, callback) => callback(item.length > 2),
  (err, result) => console.dir(result),
);

reduce(items, fn, done[, initial])

items: <Array> incoming
fn: <Function> to be executed for each value in array
- previous: <any> value previously returned in the last iteration
- current: <any> current element being processed in the array
- callback: <Function> callback for returning value back to reduce function
  - err: <Error>|<null>
  - data: <any> resulting value
- counter: <number> index of the current element being processed in array
- items: <Array> the array reduce was called upon
done: <Function> on done
- err: <Error>|<null>
- result: <Array>
initial: <any> optional value to be used as first argument in first iteration

Asynchronous reduce

reduceRight(items, fn, done[, initial])

items: <Array> incoming
fn: <Function> to be executed for each value in array
- previous: <any> value previously returned in the last iteration
- current: <any> current element being processed in the array
- callback: <Function> callback for returning value back to reduce function
  - err: <Error>|<null>
  - data: <any> resulting value
- counter: <number> index of the current element being processed in array
- items: <Array> the array reduce was called upon
done: <Function> on done
- err: <Error>|<null>
- result: <Array>
initial: <any> optional value to be used as first argument in first iteration

Asynchronous reduceRight

each(items, fn, done)

items: <Array> incoming
fn: <Function>
- value: <any> item from items array
- callback: <Function>
  - err: <Error>|<null>
done: <Function> on done
- err: <Error>|<null>
- items: <Array>

Asynchronous each (iterate in parallel)

Example:

metasync.each(
  ['a', 'b', 'c'],
  (item, callback) => {
    console.dir({ each: item });
    callback();
  },
  (err, data) => console.dir('each done'),
);

series(items, fn, done)

items: <Array> incoming
fn: <Function>
- value: <any> item from items array
- callback: <Function>
  - err: <Error>|<null>
done: <Function> on done
- err: <Error>|<null>
- items: <Array>

Asynchronous series

Example:

metasync.series(
  ['a', 'b', 'c'],
  (item, callback) => {
    console.dir({ series: item });
    callback();
  },
  (err, data) => {
    console.dir('series done');
  },
);

find(items, fn, done)

items: <Array> incoming
fn: <Function>
- value: <any> item from items array
- callback: <Function>
  - err: <Error>|<null>
  - accepted: <boolean>
done: <Function> on done
- err: <Error>|<null>
- result: <any>

Asynchronous find (iterate in series)

Example:

metasync.find(
  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
  (item, callback) => callback(null, item % 3 === 0 && item % 5 === 0),
  (err, result) => {
    console.dir(result);
  },
);

every(items, fn, done)

items: <Array> incoming
fn: <Function>
- value: <any> item from items array
- callback: <Function>
  - err: <Error>|<null>
  - accepted: <boolean>
done: <Function> on done
- err: <Error>|<null>
- result: <boolean>

Asynchronous every

some(items, fn, done)

items: <Array> incoming
fn: <Function>
- value: <any> item from items array
- callback: <Function>
  - err: <Error>|<null>
  - accepted: <boolean>
done: <Function> on done
- err: <Error>|<null>
- result: <boolean>

Asynchronous some (iterate in series)

asyncMap(items, fn[, options][, done])

items: <Array> incoming dataset
fn: <Function>
- item: <any>
- index: <number>
options: <Object> map params, optional
- min: <number> min number of items in one next call
- percent: <number> ratio of map time to all time
done: <Function> call on done, optional
- err: <Error>|<null>
- result: <Array>

Non-blocking synchronous map

asyncIter(base)

base: <Iterable>|<AsyncIterable> an iterable that is wrapped in <AsyncIterator>

Returns: <AsyncIterator>

Create an AsyncIterator instance

class AsyncIterator

AsyncIterator.prototype.constructor(base)

async AsyncIterator.prototype.next()

async AsyncIterator.prototype.count()

async AsyncIterator.prototype.each(fn, thisArg)

async AsyncIterator.prototype.forEach(fn, thisArg)

async AsyncIterator.prototype.parallel(fn, thisArg)

async AsyncIterator.prototype.every(predicate, thisArg)

async AsyncIterator.prototype.find(predicate, thisArg)

async AsyncIterator.prototype.includes(element)

async AsyncIterator.prototype.reduce(reducer, initialValue)

async AsyncIterator.prototype.some(predicate, thisArg)

async AsyncIterator.prototype.someCount(predicate, count, thisArg)

async AsyncIterator.prototype.collectTo(CollectionClass)

async AsyncIterator.prototype.collectWith(obj, collector)

async AsyncIterator.prototype.join(sep = ', ', prefix = '', suffix = '')

async AsyncIterator.prototype.toArray()

AsyncIterator.prototype.map(mapper, thisArg)

AsyncIterator.prototype.filter(predicate, thisArg)

AsyncIterator.prototype.flat(depth = 1)

AsyncIterator.prototype.flatMap(mapper, thisArg)

AsyncIterator.prototype.zip(...iterators)

AsyncIterator.prototype.chain(...iterators)

AsyncIterator.prototype.take(amount)

AsyncIterator.prototype.takeWhile(predicate, thisArg)

AsyncIterator.prototype.skip(amount)

AsyncIterator.prototype.throttle(percent, min)

AsyncIterator.prototype.enumerate()

collect(expected)

expected: <number>|<string[]>

Returns: <Collector>

Create Collector instance

class Collector

Data collector

Collector.prototype.constructor(expected)

expected: <number>|<string[]> count or keys

Data collector

Collector.prototype.collect(key, err, value)

key: <string>
err: <Error>
value: <any>

Returns: <this>

Pick or fail key

Collector.prototype.pick(key, value)

key: <string>
value: <any>

Returns: <this>

Pick key

Collector.prototype.fail(key, err)

key: <string>
err: <Error>

Returns: <this>

Fail key

Collector.prototype.take(key, fn, args)

key: <string>
fn: <Function>
args: <Array> rest arguments, to be passed in fn

Returns: <this>

Take method result

Collector.prototype.timeout(msec)

msec: <number>

Returns: <this>

Set timeout

Collector.prototype.done(callback)

callback: <Function>
- err: <Error>
- data: <any>

Returns: <this>

Set on done listener

Collector.prototype.finalize(key, err, data)

Collector.prototype.distinct(value)

value: <boolean>

Returns: <this>

Deny or allow unlisted keys

Collector.prototype.cancel(err)

Collector.prototype.then(fulfill, reject)

compose(flow)

flow: <Function[]> callback-last / err-first

Returns: <Function> composed callback-last / err-first

Asynchronous functions composition

Array of functions results in sequential execution: [f1, f2, f3] Double brackets array of functions results in parallel execution: [[f1, f2, f3]]

Example:

const composed = metasync([f1, f2, f3, [[f4, f5, [f6, f7], f8]], f9]);

class Composition

Composition.prototype.constructor()

Composition.prototype.on(name, callback)

Composition.prototype.finalize(err)

Composition.prototype.collect(err, result)

Composition.prototype.parallel()

Composition.prototype.sequential()

Composition.prototype.then(fulfill, reject)

Composition.prototype.clone()

Clone composed

Composition.prototype.pause()

Pause execution

Composition.prototype.resume()

Resume execution

Composition.prototype.timeout(msec)

msec: <number>

Set timeout

Composition.prototype.cancel()

Cancel execution where possible

firstOf(fns, callback)

fns: <Function[]> callback-last / err-first
callback: <Function> on done, err-first

Executes all asynchronous functions and pass first result to callback

parallel(fns[, context], callback)

fns: <Function[]> callback-last / err-first
context: <Object> incoming data, optional
callback: <Function> on done, err-first

Parallel execution

Example:

metasync.parallel([f1, f2, f3], (err, data) => {});

sequential(fns[, context], callback)

fns: <Function[]> callback-last with err-first contract
context: <Object> incoming data, optional
callback: <Function> err-first on done

Sequential execution

Example:

metasync.sequential([f1, f2, f3], (err, data) => {});

runIf(condition[, defaultVal], asyncFn, ...args)

condition: <any>
defaultVal: <any> optional, value that will be returned to callback if condition is falsy.
asyncFn: <Function> callback-last function that will be executed if condition if truthy
args: <any[]> args to pass to asyncFn

Run asyncFn if condition is truthy, else return defaultVal to callback.

runIfFn(asyncFn, ...args)

asyncFn: <Function> callback-last function that will be executed if it is provided
args: <any[]> args to pass to asyncFn

Run asyncFn if it is provided

class do

do.prototype.constructor(fn, ...args)

toAsync(fn)

fn: <Function> callback-last / err-first

Returns: <Function>

Convert synchronous function to asynchronous

Transform function with args arguments and callback to function with args as separate values and callback

asAsync(fn, args)

fn: <Function> asynchronous
args: <Array> its arguments

Wrap function adding async chain methods

of(args)

args: <Array>

Applicative f => a -> f a

concat(fn1, fn2)

fn1: <Function>
fn2: <Function>

Monoid m => a -> a -> a

fmap(fn1, f)

fn1: <Function>
f: <Function>

Functor f => (a -> b) -> f a -> f b

ap(fn, funcA)

fn: <Function>
funcA: <Function>

Applicative f => f (a -> b) -> f a -> f b

memoize(fn)

fn: <Function> sync or async

Returns: <Function> memoized

Create memoized function

class Memoized

Memoized.prototype.constructor()

Memoized.prototype.clear()

Memoized.prototype.add(key, err, data)

Memoized.prototype.del(key)

Memoized.prototype.get(key, callback)

Memoized.prototype.on(eventName, listener)

eventName: <string>
listener: <Function> handler

Add event listener

Example:

const memoized = new Memoized();
memoized.on('memoize', (err, data) => { ... });
memoized.on('add', (key, err, data) => { ... });
memoized.on('del', (key) => { ... })
memoized.on('clear', () => { ... });

Memoized.prototype.emit(eventName, args)

eventName: <string>
args: <any> rest arguments

Emit Memoized events

poolify(factory, min, norm, max)

queue(concurrency)

concurrency: <number> simultaneous and asynchronously executing tasks

Returns: <Queue>

Create Queue instance

class Queue

Queue constructor

Queue.prototype.constructor(concurrency)

concurrency: <number> asynchronous concurrency

Queue constructor

Queue.prototype.wait(msec)

msec: <number> wait timeout for single item

Returns: <this>

Set wait before processing timeout

Queue.prototype.throttle(count[, interval])

count: <number> item count
interval: <number> per interval, optional default: 1000 msec

Returns: <this>

Throttle to limit throughput

Queue.prototype.add(item[, factor[, priority]])

item: <Object> to be added
factor: <number>|<string> type, source, destination or path, optional
priority: <number> optional

Returns: <this>

Add item to queue

Queue.prototype.next(task)

task: <Array> next task [item, factor, priority]

Returns: <this>

Process next item

Queue.prototype.takeNext()

Returns: <this>

Prepare next item for processing

Queue.prototype.pause()

Returns: <this>

Pause queue

This function is not completely implemented yet

Queue.prototype.resume()

Returns: <this>

Resume queue

This function is not completely implemented yet

Queue.prototype.clear()

Returns: <this>

Clear queue

Queue.prototype.timeout(msec, onTimeout)

msec: <number> process timeout for single item
onTimeout: <Function>

Returns: <this>

Set timeout interval and listener

Queue.prototype.process(fn)

fn: <Function>
- item: <Object>
- callback: <Function>
  - err: <Error>|<null>
  - result: <any>

Returns: <this>

Set processing function

Queue.prototype.done(fn)

fn: <Function> done listener
- err: <Error>|<null>
- result: <any>

Returns: <this>

Set listener on processing done

Queue.prototype.success(listener)

listener: <Function> on success
- item: <any>

Returns: <this>

Set listener on processing success

Queue.prototype.failure(listener)

listener: <Function> on failure
- err: <Error>|<null>

Returns: <this>

Set listener on processing error

Queue.prototype.drain(listener)

listener: <Function> on drain

Returns: <this>

Set listener on drain Queue

Queue.prototype.fifo()

Returns: <this>

Switch to FIFO mode (default for Queue)

Queue.prototype.lifo()

Returns: <this>

Switch to LIFO mode

Queue.prototype.priority(flag)

flag: <boolean> default: true, false will disable priority mode

Returns: <this>

Activate or deactivate priority mode

Queue.prototype.roundRobin(flag)

flag: <boolean> default: true, false will disable roundRobin mode

Returns: <this>

Activate or deactivate round robin mode

Queue.prototype.pipe(dest)

dest: <Queue> destination queue

Returns: <this>

Pipe processed items to different queue

throttle(timeout, fn, ...args)

timeout: <number> msec interval
fn: <Function> to be throttled
args: <Array> arguments for fn, optional

Returns: <Function>

Get throttling function, executed once per interval

debounce(timeout, fn, ...args)

timeout: <number> msec
fn: <Function> to be debounced
args: <Array> arguments for fn, optional

Debounce function, delayed execution

timeout(timeout, fn, callback)

timeout: <number> time interval
fn: <Function> to be executed
callback: <Function> callback(...args), on done
- args: <Array>

Set timeout for asynchronous function execution

Contributors

Timur Shemsedinov (marcusaurelius)
See github for full contributors list

Name		Name	Last commit message	Last commit date
Latest commit History 373 Commits
.github		.github
doc		doc
lib		lib
test		test
tests		tests
.babelrc		.babelrc
.editorconfig		.editorconfig
.eslintignore		.eslintignore
.eslintrc.json		.eslintrc.json
.gitattributes		.gitattributes
.gitignore		.gitignore
.metadocrc		.metadocrc
.prettierignore		.prettierignore
.prettierrc		.prettierrc
AUTHORS		AUTHORS
LICENSE		LICENSE
README.md		README.md
metasync.js		metasync.js
package-lock.json		package-lock.json
package.json		package.json

License

metarhia/metasync

Folders and files

Latest commit

History

Repository files navigation

Asynchronous Programming Library

Installation

Asynchronous functions composition

API

callbackify(fn)

asyncify(fn)

promiseToCallbackLast(promise, callback)

promisify(fn)

promisifySync(fn)

map(items, fn, done)

filter(items, fn, done)

reduce(items, fn, done[, initial])

reduceRight(items, fn, done[, initial])

each(items, fn, done)

series(items, fn, done)

find(items, fn, done)

every(items, fn, done)

some(items, fn, done)

asyncMap(items, fn[, options][, done])

asyncIter(base)

class AsyncIterator

AsyncIterator.prototype.constructor(base)

async AsyncIterator.prototype.next()

async AsyncIterator.prototype.count()

async AsyncIterator.prototype.each(fn, thisArg)

async AsyncIterator.prototype.forEach(fn, thisArg)

async AsyncIterator.prototype.parallel(fn, thisArg)

async AsyncIterator.prototype.every(predicate, thisArg)

async AsyncIterator.prototype.find(predicate, thisArg)

async AsyncIterator.prototype.includes(element)

async AsyncIterator.prototype.reduce(reducer, initialValue)

async AsyncIterator.prototype.some(predicate, thisArg)

async AsyncIterator.prototype.someCount(predicate, count, thisArg)

async AsyncIterator.prototype.collectTo(CollectionClass)

async AsyncIterator.prototype.collectWith(obj, collector)

async AsyncIterator.prototype.join(sep = ', ', prefix = '', suffix = '')

async AsyncIterator.prototype.toArray()

AsyncIterator.prototype.map(mapper, thisArg)

AsyncIterator.prototype.filter(predicate, thisArg)

AsyncIterator.prototype.flat(depth = 1)

AsyncIterator.prototype.flatMap(mapper, thisArg)

AsyncIterator.prototype.zip(...iterators)

AsyncIterator.prototype.chain(...iterators)

AsyncIterator.prototype.take(amount)

AsyncIterator.prototype.takeWhile(predicate, thisArg)

AsyncIterator.prototype.skip(amount)

AsyncIterator.prototype.throttle(percent, min)

AsyncIterator.prototype.enumerate()

collect(expected)

class Collector

Collector.prototype.constructor(expected)

Collector.prototype.collect(key, err, value)

Collector.prototype.pick(key, value)

Collector.prototype.fail(key, err)

Collector.prototype.take(key, fn, args)

Collector.prototype.timeout(msec)

Collector.prototype.done(callback)

Collector.prototype.finalize(key, err, data)

Collector.prototype.distinct(value)

Collector.prototype.cancel(err)

Collector.prototype.then(fulfill, reject)

compose(flow)

class Composition

Composition.prototype.constructor()

Composition.prototype.on(name, callback)

Composition.prototype.finalize(err)

Composition.prototype.collect(err, result)

Composition.prototype.parallel()

Composition.prototype.sequential()

Composition.prototype.then(fulfill, reject)

Composition.prototype.clone()

Composition.prototype.pause()

Composition.prototype.resume()

Composition.prototype.timeout(msec)