diff --git a/docs/createMemo.md b/docs/createMemo.md
index 2b3f8c5da6..9dc82c3d78 100644
--- a/docs/createMemo.md
+++ b/docs/createMemo.md
@@ -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
@@ -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
{total}
;
+};
+```
+
## Reference
diff --git a/src/factory/createMemo.ts b/src/factory/createMemo.ts
index 8fe16ee90a..e9ab8216f6 100644
--- a/src/factory/createMemo.ts
+++ b/src/factory/createMemo.ts
@@ -1,8 +1,20 @@
-import { useMemo } from 'react';
+import { useMemo, useRef } from 'react';
const createMemo =
any>(fn: T) =>
- (...args: Parameters) =>
- useMemo>(() => fn(...args), args);
+ (...args: Parameters) => {
+ 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>(() => fn(...memoizedArgs), [memoizedArgs]);
+ };
export default createMemo;
diff --git a/tests/createMemo.test.ts b/tests/createMemo.test.ts
index 0cf4e0d130..790edda52d 100644
--- a/tests/createMemo.test.ts
+++ b/tests/createMemo.test.ts
@@ -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; nextArgs: Array }>([
+ { 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) => 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);
+});