Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 16 additions & 0 deletions docs/createMemo.md
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,10 @@
Hook factory, receives a function to be memoized, returns a memoized React hook,
which receives the same arguments and returns the same result as the original function.

Arguments are compared individually using `Object.is`. The result is recalculated
when an argument changes or the number of arguments changes. Each hook instance
keeps its own memoized result.


## Usage

Expand All @@ -28,6 +32,18 @@ const Demo = () => {
};
```

Functions with optional or rest parameters can receive a different number of
arguments on each render:

```jsx
const useMemoSum = createMemo((...values) => values.reduce((sum, value) => sum + value, 0));

const Demo = ({ values }) => {
const total = useMemoSum(...values);
return <div>{total}</div>;
};
```


## Reference

Expand Down
18 changes: 15 additions & 3 deletions src/factory/createMemo.ts
Original file line number Diff line number Diff line change
@@ -1,8 +1,20 @@
import { useMemo } from 'react';
import { useMemo, useRef } from 'react';

const createMemo =
<T extends (...args: any) => any>(fn: T) =>
(...args: Parameters<T>) =>
useMemo<ReturnType<T>>(() => fn(...args), args);
(...args: Parameters<T>) => {
const argsRef = useRef(args);

if (
args.length !== argsRef.current.length ||
args.some((argument, index) => !Object.is(argument, argsRef.current[index]))
) {
argsRef.current = args;
}

const memoizedArgs = argsRef.current;

return useMemo<ReturnType<T>>(() => fn(...memoizedArgs), [memoizedArgs]);
};

export default createMemo;
106 changes: 106 additions & 0 deletions tests/createMemo.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -46,3 +46,109 @@ describe('when using created memo hook', () => {
expect(getDouble).toHaveBeenCalled();
});
});

describe('when the number of arguments changes', () => {
let consoleError: jest.SpyInstance;

beforeEach(() => {
consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
});

afterEach(() => {
consoleError.mockRestore();
});

it.each<{ initialArgs: Array<number | undefined>; nextArgs: Array<number | undefined> }>([
{ initialArgs: [], nextArgs: [1] },
{ initialArgs: [1], nextArgs: [] },
{ initialArgs: [1], nextArgs: [1, 2] },
{ initialArgs: [1, 2], nextArgs: [1] },
{ initialArgs: [], nextArgs: [undefined] },
{ initialArgs: [undefined], nextArgs: [] },
])('should recalculate when argument count changes (%j)', ({ initialArgs, nextArgs }) => {
const collect = jest.fn((...args: Array<number | undefined>) => args);
const useCollect = createMemo(collect);
const { result, rerender } = renderHook(({ args }) => useCollect(...args), {
initialProps: { args: initialArgs },
});

expect(result.current).toEqual(initialArgs);

rerender({ args: nextArgs });

expect(result.current).toEqual(nextArgs);
expect(collect).toHaveBeenCalledTimes(2);
expect(consoleError).not.toHaveBeenCalled();

const previousResult = result.current;
rerender({ args: [...nextArgs] });

expect(result.current).toBe(previousResult);
expect(collect).toHaveBeenCalledTimes(2);
});
});

it('should memoize a call without arguments', () => {
const fn = jest.fn(() => ({}));
const useMemoFn = createMemo(fn);
const { result, rerender } = renderHook(() => useMemoFn());
const initialResult = result.current;

rerender();

expect(result.current).toBe(initialResult);
expect(fn).toHaveBeenCalledTimes(1);
});

it('should compare arguments with Object.is semantics', () => {
const fn = jest.fn((value: number) => ({ value }));
const useMemoFn = createMemo(fn);
const { result, rerender } = renderHook(({ value }) => useMemoFn(value), {
initialProps: { value: NaN },
});
const initialResult = result.current;

rerender({ value: NaN });

expect(result.current).toBe(initialResult);
expect(fn).toHaveBeenCalledTimes(1);

rerender({ value: 0 });
expect(result.current.value).toBe(0);

rerender({ value: -0 });
expect(result.current.value).toBe(-0);
expect(fn).toHaveBeenCalledTimes(3);
});

it('should compare object arguments by identity', () => {
const fn = jest.fn((value: object) => ({ value }));
const useMemoFn = createMemo(fn);
const value = {};
const { result, rerender } = renderHook(({ argument }) => useMemoFn(argument), {
initialProps: { argument: value },
});
const initialResult = result.current;

rerender({ argument: value });
expect(result.current).toBe(initialResult);
expect(fn).toHaveBeenCalledTimes(1);

const nextValue = {};
rerender({ argument: nextValue });
expect(result.current.value).toBe(nextValue);
expect(fn).toHaveBeenCalledTimes(2);
});

it('should memoize each hook instance separately', () => {
const fn = jest.fn((value: number) => ({ value }));
const useMemoFn = createMemo(fn);
const { result, rerender } = renderHook(() => [useMemoFn(1), useMemoFn(2)]);
const initialResults = result.current;

rerender();

expect(result.current[0]).toBe(initialResults[0]);
expect(result.current[1]).toBe(initialResults[1]);
expect(fn).toHaveBeenCalledTimes(2);
});