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

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 { <pending> }
// 3
// 2
// resolved

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.

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.