An aggressive async flow solution for node.js. 

evshiron

node-async-flow

        console.trace(chalk.yellow('DEPRECATED: Use cb.single or cb.expect if possible.'));

        return arguments.length > 1 ? instance.next(arguments) : instance.next(arguments[0]);

        return process.nextTick(function() {

            var params = Array.from(arguments);

            var params = Array.prototype.slice.call(arguments, 0);

            return process.nextTick(() => {

            return process.nextTick(function() {

        var keys = Array.prototype.slice.call(arguments, 0);

            keys.map((key, idx) => map[key] = arguments[idx]);

            keys.map(function(key, idx) {

const WaitUntil = (condition, timeout, cb) => {

function WaitUntil(condition, timeout, cb) {

    const INTERVAL = Math.max(timeout / 100, 33);

        else if(counter >= timeout) return cb(false);

    "test": "echo \"Error: no test specified\" && exit 1"

    "url": "git+https://github.com/evshiron/node-async-flow.git"

    "url": "https://github.com/evshiron/node-async-flow/issues"

  "homepage": "https://github.com/evshiron/node-async-flow#readme",

An aggressive async flow solution for node.js 4.x+.

Enable `--harmony-destructuring` and `--harmony-rest-parameters` if necessary.

Also works with `babel` with `babel-polyfill` enabled.

node.js is excellent for it's advanced support for new standards. But it's been a headache as there are callbacks everywhere and it's hard to compose logic between them.

Peoples have been attempting to solve this situation for a long time:

The `async` provides handy utility functions to chain things together, along with a central error handing mechanism. It saves some nested callbacks but doesn't solve the problem.

There are also many Promise implementations, like `q` and `bluebird`. I personally dislike Promises because it's a standard which makes things harder: everything is in chainable callbacks and now we have a nice constructor and resolve and reject and then and catch, wow!

The `co` is the widely used generator-based solution for the callback hells. It's similar to the async/await standard and use Promises. To be used with `co`, everything should be Promises or "thunkified", which is another story.

* No wrapper needed for existing code (compared to `new Promise` and `thunkify`)

* No need to pass variables every next step

* In place error handling (if error is solvable let's continue)

See [examples](./examples/), [tests](./tests/), [nwjs-download](https://github.com/evshiron/nwjs-download) and [nwjs-builder](https://github.com/evshiron/nwjs-builder) :)

const { exists, readFile } = require('fs');

// Async check file exists and do something.

  if(yield exists('package.json', cb.single)) {

  var [err, data] = yield readFile('package.json', { encoding: 'utf-8' }, cb.expect(2));

  var [err, json] = yield readFile('package.json', { encoding: 'utf-8' }, (err, data) => err ? cb.expect(2)(err) : cb.expect(2)(null, JSON.parse(data));

  var [err, json] = yield require('fs-extra').readJson('package.json', cb.expect(2));

const getOneValue = (callback) => setTimeout(() => callback(true), 0);

const getTwoValues = (callback) => setTimeout(() => callback(true, false), 0);

const getThreeValues = (callback) => setTimeout(() => callback(true, false, null), 0);

  var x = yield getOneValue(cb.expect(1));

  var [x] = yield getOneValue(cb.expect(1));

  var [x, y] = yield getTwoValues(cb.expect(1));

  var [x, y] = yield getTwoValues(cb.expect(2));

  var {z, y, x} = yield getThreeValues(cb.map('x', 'y', 'z'));

		@@ -14,3 +14,3 @@
		cb.single = function(value) {
		return process.nextTick(() => {
		return process.nextTick(function() {
		instance.next(value);
		@@ -22,5 +22,5 @@ });
		return function() {
		var params = Array.from(arguments);
		var params = Array.prototype.slice.call(arguments, 0);
		params.length = count;
		return process.nextTick(() => {
		return process.nextTick(function() {
		instance.next(params);
		@@ -36,5 +36,8 @@ });
		return function() {
		var params = Array.prototype.slice.call(arguments, 0);
		var map = {};
		keys.map((key, idx) => map[key] = arguments[idx]);
		return process.nextTick(() => {
		keys.map(function(key, idx) {
		map[key] = params[idx];
		});
		return process.nextTick(function() {
		instance.next(map);
		@@ -52,5 +55,2 @@ });
		module.exports = Flow;

		Object.assign(module.exports, {
		util: require('./util')
		});
		module.exports.util = require('./util');


		const WaitUntil = (condition, timeout, cb) => {
		function WaitUntil(condition, timeout, cb) {

		@@ -8,3 +8,3 @@ const INTERVAL = Math.max(timeout / 100, 33);

		const wait = () => {
		function wait() {

		@@ -17,10 +17,8 @@ counter += INTERVAL;

		};
		}

		setTimeout(wait, INTERVAL);

		};
		}

		Object.assign(module.exports, {
		WaitUntil
		});
		module.exports.WaitUntil = WaitUntil;

		{
		"name": "node-async-flow",
		"version": "1.2.1",
		"version": "1.3.0",
		"description": "",
		@@ -5,0 +5,0 @@ "main": "./lib/index.js",

		# node-async-flow

		An aggressive async flow solution for node.js 4.x+.
		An aggressive async flow solution for node.js.

		Generators are required.
		The support for Generator is required.

		Enable `--harmony-destructuring` and `--harmony-rest-parameters` if necessary.

		Also works with `babel` with `babel-polyfill` enabled.

		## Why?
		@@ -12,0 +8,0 @@

Worsened metrics