sync

Interface LatestConstructor<TFn>

Source
Expand description

Args for constructing latest

latest is an async event wrapper that always resolve to the result of the latest call

In the example below, both call will return the result of the second call (2)

import { latest } from "@pistonite/pure/sync";

let counter = 0;

const execute = latest({
    fn: async () => {
        counter++;
        await new Promise((resolve) => setTimeout(() => {
            resolve(counter);
        }, 1000));
    }
});

const result1 = execute();
const result2 = execute();
console.log(await result1); // 2
console.log(await result2); // 2

See the constructor options for more advanced usage, for example, control how arguments are updated when new calls are made.

interface LatestConstructor<TFn extends AnyFn> {
    areArgsEqual?: (a: Parameters<TFn>, b: Parameters<TFn>) => boolean;
    fn: TFn;
    updateArgs?: LatestUpdateArgsFn<TFn>;
}

Properties§

§areArgsEqual?: { ... }

Optional function to compare if arguments of 2 calls are equal.

By default, separate calls are considered different, and the result of the latest call will be returned. However, if the function is pure, and the argument of a new call is the same as the call being executed, then the result of the call being executed will be returned. In other words, the new call will not result in another execution of the function.

§fn: TFn

Function to be wrapped

§updateArgs?: LatestUpdateArgsFn<TFn>

Optional function to update the arguments.

By default, when new calls are made while the previous call is being executed, The function will be executed again with the latest arguments. This function is used to change this behavior and is called when new calls are made. In other words, the default value for this function is (_current, _middle, latest) => latest.

The arguments are:

  • current: The arguments of the call currently being executed
  • latest: The argument of this new call
  • middle: If more than one call is made while the previous call is being executed, this array contains arguments of the calls between current and latest
  • next: This is the returned value of the previous call to updateArgs, i.e. the args to be executed next.