@marcelkloubert/promises

import assert from "assert"
import { doRepeat, DoRepeatActionContext } from "@marcelkloubert/promises"

const repeatCount = 5979
const counter = 0

const results = await doRepeat(async (context: DoRepeatActionContext) => {
  console.log("context.state", String(context.state))
  context.state = context.index * 2

  ++counter

  // do some work here
}, repeatCount)

assert.strictEqual(results.length, repeatCount)
assert.strictEqual(counter, results.length)

PartlyFailedErrorAt least one execution failed.

import { waitFor, WaitForActionContext, WaitForCondition } from "@marcelkloubert/promises"
import fs from "fs"

const waitForFile: WaitForCondition = async (context) => {
  // use context.cancel() function
  // to cancel the operation
  // maybe for a timeout

  // setup 'state' value for upcoming
  // action
  context.state = "Foo Bar BUZZ" // (s. below in action)

  // return a truthy value to keep waiting
  // otherwise falsy to start execution of action
  return !fs.existsSync("/path/to/my/file.xlsx")
}

const result = await waitFor(async ({ state }: WaitForActionContext) => {
  // state === "Foo Bar BUZZ" (s. above)
}, waitForFile)

import { CancellationError, withCancellation, WithCancellationActionContext } from "@marcelkloubert/promises"

const promise = withCancellation(async (context: WithCancellationActionContext) => {
  let hasBeenFinished = false
  while (!context.cancellationRequested && !hasBeenFinished) {
    // do some long work here
  }
})

setTimeout(() => {
  promise.cancel("Promise action takes too long")
}, 10000)

try {
  await promise
} catch (ex) {
  if (ex instanceof CancellationError) {
    // has been cancelled
  } else {
    // other error
  }
}

import { MaximumTriesReachedError, withRetries } from "@marcelkloubert/promises"

const myLongAction = async () => {
  // do something here
}

try {
  // try this action
  await withTimeout(myLongAction, {
    maxRetries: 9, // try invoke the myLongAction
                   // with a maximum of 10 times
                   // (first invocation + maxRetries)
    waitBeforeRetry: 10000, // wait 10 seconds, before retry
  })
} catch (error) {
  // error should be a MaximumTriesReachedError instance
  console.error("Invokation of myLongAction failed", error)
}

MaximumTriesReachedError Action has run into a timeout.

import { TimeoutError, withTimeout } from "@marcelkloubert/promises"

const action = () => {
  return new Promise<string>((resolve) => {
    setTimeout(() => result("FOO"), 1000)
  })
}

// submit action as function
// should NOT throw a TimeoutError
const fooResult1 = await withTimeout(action, 10000)

// submit action as Promise
// this should throw a TimeoutError
const fooResult2 = await withTimeout(action(), 100)

TimeoutError Action has run into a timeout.

import { withWorker } from "@marcelkloubert/promises"

// this is code for Node.js
// in a browser 'exitCode' will not exist
const { exitCode, lastMessage } = await withWorker("/path/to/worker_script.js")