asyncSeries.js  

Asynchronously process a list of items consecutively.

Even though the processing is asynchronous, it is never done in parallel.

Install

``sh
npm i -S @duzun/async-series
`

Import or require

This library can be included either as an ESM or UMD.

#### ESM

`js
import {
forEach as eachSeries,
map as mapSeries,
reduce as reduceSeries
} from '@duzun/async-series';
`

#### CommonJS

`js
const {
forEach: eachSeries,
map : mapSeries,
reduce : reduceSeries,
} = require('@duzun/async-series');
`

#### AMD

`js
require('https://unpkg.com/@duzun/async-series', (asyncSeries) => {
const {
forEach: eachSeries,
map : mapSeries,
reduce : reduceSeries,
} = asyncSeries;

// ...
});
`

#### Browser

`html


`

Usage by example

$3


##### Where [async ]iteratee(value, index, array)

Process file contents of a directory, asynchronously & consecutively.

`js
const fs = require('mz/fs');
const { forEach: eachSeries } = require('@duzun/async-series');

(async () => {
let files = await fs.readdir('.');
let results = await eachSeries(files, async (filename, idx) => {
if((await fs.stat(filename)).isDirectory()) return;
let contents = await fs.readFile(filename);

// Do some heavy processing here...
});
})();
`

$3


##### Where [async ]iteratee(value, index, array)

Get file contents of a directory, asynchronously & consecutively;

`js
const fs = require('mz/fs');
const { map: mapSeries } = require('@duzun/async-series');

(async () => {
let files = await fs.readdir('.');
let contents = await mapSeries(files, async (filename, idx) => {
if((await fs.stat(filename)).isDirectory()) return;
return fs.readFile(filename, 'utf8');
});
contents = contents.filter((x) => x);
})();
`

$3


##### Where [async ]reducer(accumulator, currentValue, index, array)

Calculate file sizes in a directory, asynchronously & consecutively.

`js
const fs = require('mz/fs');
const { reduce: reduceSeries } = require('@duzun/async-series');

(async () => {
let files = await fs.readdir('.');
let size = await reduceSeries(files, async (size, filename, idx) => {
let stats = await fs.stat(filename);
if(stats.isDirectory()) return size;
return size + stats.size;
}, 0);

console.log('size: ', size);
})();

``

Why?

Why not? :)

I know, there is a great library Async.js, which already has eachSeries, mapSeries and reduce and many other functions.

This library is < 900 bytes minified, and < 500 bytes when also gzipped.

And if you include it with rollup.js, you only get the function you've imported.