once

1/**
2 * Ensures a function is only called once.
3 * Provides a `.reset()` method to allow re-invocation.
4 *
5 * @param fn - The function to wrap.
6 * @returns A function that can only be called once, with `.reset()` method.
7 */
8export function once<T extends (...args: any[]) => any>(
9  fn: T
10): ((...args: Parameters<T>) => ReturnType<T>) & { reset: () => void } {
11  let called = false;
12  let result: ReturnType<T>;
13
14  const wrapper = (...args: Parameters<T>) => {
15    if (!called) {
16      result = fn(...args);
17      called = true;
18    }
19    return result;
20  };
21
22  wrapper.reset = () => {
23    called = false;
24    result = undefined as any;
25  };
26
27  return wrapper;
28}

1test('once - only calls function once', () => {
2  const fn = jest.fn((x: number) => x * 2);
3  const wrapped = once(fn);
4
5  expect(wrapped(2)).toBe(4);
6  expect(wrapped(3)).toBe(4); // returns first result
7  expect(wrapped(10)).toBe(4);
8  expect(fn).toHaveBeenCalledTimes(1);
9});
10
11test('once - no arguments', () => {
12  const fn = jest.fn(() => 'ran');
13  const wrapped = once(fn);
14
15  expect(wrapped()).toBe('ran');
16  expect(wrapped()).toBe('ran');
17  expect(fn).toHaveBeenCalledTimes(1);
18});
19
20test('once - reset allows re-invocation', () => {
21  const fn = jest.fn((x: number) => x + 1);
22  const wrapped = once(fn);
23
24  expect(wrapped(1)).toBe(2);
25  expect(wrapped(2)).toBe(2);
26  expect(fn).toHaveBeenCalledTimes(1);
27
28  wrapped.reset();
29
30  expect(wrapped(5)).toBe(6);
31  expect(fn).toHaveBeenCalledTimes(2);
32});