function-loop

Run a list of synchronous or asynchronous functions, and call a
function at the end.

USAGE

``ts
import { loop } from 'function-loop'
// or const { loop } = require('function-loop')

const loop = require('./dist/cjs/index.js').default

// synchronous usage
const list = [
() => console.log(1),
() => console.log(2),
() => console.log(3),
]
const result = loop(list, () => {
console.log('done')
return true
}, (er) => {
console.error('threw somehow', er)
})

console.log('result:', result)
// logs:
// 1
// 2
// 3
// done
// result: true

// asynchronous usage
const plist = [
async () => console.log(1),
async () => new Promise(resolve => setTimeout(resolve, 100)).then(() =>
console.log(2)
),
async () => console.log(3),
]
const presult = loop(plist, () => {
console.log('done')
return true
}, (er) => {
console.error('threw somehow', er)
})

console.log('result:', presult)
presult.then(() => console.log('resolved'))
// logs:
// 1
// result: Promise { }
// 3
// 2
// resolved
``

Zalgo Preserving

This module is
"zalgo-preserving",
meaning that synchronous returns will result in a sync call to
the supplied cb, and async calls will result in the done callback
being called asynchronously. The loop will return a Promise
indicating when it is finished, if any async functions are
encountered. It does not artificially defer if functions are
called synchronously.

API

loop(functionList, doneCallback, errorCallback)

Run all the functions and then call the doneCallback or call
the errorCallback if there are any errors.

Functions are called without being bound to any object as this.

Functions can return a Promise to do async operations, or not if
they are done synchronously. Throws and Promise rejection are
reported to the errorCallback provided.

Return value is the return value of the callback, or a Promise`
resolving to the callback's return value if any of the functions
in the list return promises.