@opdime/delay v0.4.1

Delay-JS

Delay-JS is a library which enables you to delay functions, iterables, iterators, and generators. Note! Asynchronous generators are not supported yet but will be supported soon.

delay(milliseconds)

Creates a Promise which resolves earliest after the given milliseconds.

All of the following delay functions can also be curried. An example for this currying will be shown in the documentation for the function delayFunction.

delayFunction(milliseconds[, func])

Creates a new function which returns a Promise that resolves earliest after the given milliseconds.

import { delayFunction } from '@opdime/delay';
// invoking the delayFunction directly
const logAfterOneSecond = delayFunction(1000, console.log);

logAfterOneSecond('some text');

// curry delayFunction
const delayFunctionForOneSecond = delayFunction(1000);
// then create functions which are delayed for one second
const logAfterOneSecond = delayFunctionForOneSecond(console.log);

logAfterOneSecond('some text');

delayGenerator(milliseconds[, generator])

Creates a new async generator function from the given generator function. Each element of the new generator will be resolved after the given milliseconds.

import { delayGenerator } from '@opdime/delay';
function someGenerator*() {
  yield 1;
  yield 2;
  yield 3;
}

const someDelayedGenerator(200, someGenerator);

// each iteration will take 200ms
for await (const value of someDelayedGenerator()) {
  console.log(value);
}
// reached after at least 600ms (200ms for each generator item)

delayIterable(milliseconds[, iterable])

Creates the same output as delayGenerator, but expects an iterable instead of a generator.

delayThrow(milliseconds[, value])

Returns a Promise which will be rejected after the given time. The provided value is going to be passed to the catch statement.

import { delayThrow } from '@opdime/delay';

delayThrow(200)
  .then(() => console.log('everything is fine'))
  .catch(() => console.log('actually not!'));

delayValue(milliseconds[, value])

Returns a Promise which resolves to the given value after the given milliseconds have passed.