How to throttle an array of promises until they've resolved

async-patterns.js

const delay =
  (ms) => // HOF, aka "constructor" providing state
    () => // <<-- the thunk, executes a promise //
      new Promise(
          (resolve) => {
            console.log('start work for >>', ms, 'ms')
            setTimeout(resolve, ms, ms)
          }
      )

let line = 0
const logger = async (...args) => console.log(line++, ':', ...args)

// instantiate new Array<thunk>
const resetThunks = () => [
  delay(1000),
  delay(100),
  delay(2000),
  delay(500),
]

async function main() {
  /////// SYNC all confirm
  let thunks = resetThunks()
  await thunks.reduce( // returns final Promise
    async (prevPromise, currThunk) => {
      await prevPromise
      return currThunk().then(logger)
    },
    Promise.resolve())
  logger('!!!!!!! reduce DONE\n')

  /////// ASYNC, all confirm
  thunks = resetThunks()
  await Promise.all(
    thunks.map( // returns an Array<Promise>
      currThunk => currThunk().then(logger)
    ))
  logger('!!!!!!! all map DONE\n')

  ////// ASYNC, fastest confirm
  thunks = resetThunks()
  await Promise.race(
    thunks.map( // returns an Array<Promise>
      currThunk => currThunk().then(logger)
    ))
  logger('!!!!!!! race map DONE\n')

  logger('MORE WORK... lalala\n\n\n')
}

main()
'MAIN IS DONE'