@mic-rexjs/usecases-react 1.7.8 → 2.0.0

package/es/hooks/useUseCase/index.test.js

@@ -5,9 +5,11 @@ import { renderHook, act, render, fireEvent, screen } from '@testing-library/rea
 import { useUseCase } from '.';
 import { useDeepCompareEffect, useMemoizedFn, useMount, useUpdate, useUpdateEffect } from 'ahooks';
 import { Fragment, useEffect, useRef, useState } from 'react';
+import { UseCaseModes } from '../../enums/UseCaseModes';
 const EXT_1 = '.png';
 const EXT_2 = '.jpg';
 const PATH_1 = `hello${EXT_1}`;
+const PATH_2 = `hello${EXT_2}`;
 const PARENT_BUTTON_TEXT = 'parent button';
 const CHILD_BUTTON_TEXT = 'child button';
 const defaultFile = {
@@ -65,7 +67,7 @@ const Child = ({ textPrefix = '', onUpdate, onPathChange, onUndefinedEntity }) =
     const [file, { setPath }] = useUseCase(fileUseCase);
     const { path, ext } = file || {};
     const onClick = () => {
-        setPath('');
+        setPath(PATH_2);
     };
     const undefinedEntity = useMemoizedFn(() => {
         onUndefinedEntity?.();
@@ -84,8 +86,8 @@ const Child = ({ textPrefix = '', onUpdate, onPathChange, onUndefinedEntity }) =
     useUpdateEffect(pathChange, [path, pathChange]);
     return (_jsxs("div", { children: [_jsxs("main", { children: ["child path: ", path, _jsx("br", {}), "child ext: ", ext] }), _jsx("footer", { children: _jsx("button", { onClick: onClick, children: textPrefix + CHILD_BUTTON_TEXT }) })] }));
 };
-const Parent = ({ children, stateless, onUpdate, onSetPath }) => {
-    const [{ path, ext }, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, { stateless });
+const Parent = ({ children, mode, onUpdate, onSetPath }) => {
+    const [{ path, ext }, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, mode);
     const onClick = () => {
         setPath(onSetPath?.() || '');
     };
@@ -122,17 +124,17 @@ beforeEach(() => {
     subtractionReducer.mockClear();
 });
 describe('useUseCase', () => {
-    describe('`useUseCase` should work with 2+ arguments on provider mode', () => {
+    describe.each([void 0, UseCaseModes.Normal, UseCaseModes.Global])('[mode=%s]: `useUseCase` should work the same as `useRootCoreCollection`', (mode) => {
         test('check `context.length`', () => {
             const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase);
+                return useUseCase(defaultFile, fileUseCase, mode);
             });
             const { current: cores } = result;
             expect(cores).toHaveLength(3);
         });
         test('`entity` should equal `defaultFile`', () => {
             const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase);
+                return useUseCase(defaultFile, fileUseCase, mode);
             });
             const { current: cores } = result;
             const [entity] = cores;
@@ -410,13 +412,13 @@ describe('useUseCase', () => {
             fireEvent.click(screen.getByText(updateButtonText));
             expect(addReducer).toHaveBeenCalledTimes(3);
         });
-        test('`options.stateless` should not generate new reducers when `yeild entity`', () => {
+        test('stateless mode should not generate new reducers when `yeild entity`', () => {
             const onUpdate = jest.fn();
             const { result, rerender } = renderHook((file = defaultFile) => {
                 useUpdateEffect(() => {
                     onUpdate();
                 });
-                return useUseCase(file, fileUseCase, { stateless: true });
+                return useUseCase(file, fileUseCase, UseCaseModes.Stateless);
             });
             const { current: cores } = result;
             const [, { setPath }] = cores;
@@ -428,13 +430,13 @@ describe('useUseCase', () => {
             expect(result.current[0].path).toBe(PATH_1);
             expect(result.current[1].setPath).not.toBe(setPath);
         });
-        test('`options.stateless` should not trigger update when after `yield entity`', () => {
+        test('stateless mode should not trigger update when after `yield entity`', () => {
             const onUpdate = jest.fn();
             const { result } = renderHook(() => {
                 useUpdateEffect(() => {
                     onUpdate();
                 });
-                return useUseCase(defaultFile, fileUseCase, { stateless: true });
+                return useUseCase(defaultFile, fileUseCase, UseCaseModes.Stateless);
             });
             const { current: cores } = result;
             const [, reducers] = cores;
@@ -1110,216 +1112,96 @@ describe('useUseCase', () => {
                 oldValue: EXT_1,
             });
         });
-    });
-    describe('`useUseCase` should work with 1+ arguments on non-entity mode', () => {
-        test('`entity` should equal `defaultFile`', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase);
-            });
-            const { current: reducers } = result;
-            expect(Array.isArray(reducers)).toBe(false);
-        });
-        test('returned reducer should work', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase);
-            });
-            const { current: reducers } = result;
-            const { add } = reducers;
-            expect(add(1, 2)).toBe(3);
-        });
-        test('`usecase` should be called only once if deps has not provided', () => {
-            const mockUseCase = jest.fn(mathUseCase);
-            const { rerender } = renderHook(() => {
-                return useUseCase(mockUseCase);
-            });
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
-            rerender();
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
-        });
-        test('`usecase` should be called only once if deps has not changed', () => {
-            const mockUseCase = jest.fn(mathUseCase);
-            const { rerender } = renderHook(() => {
-                return useUseCase(mockUseCase, {}, [1, 'x']);
-            });
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
-            rerender();
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
-        });
-        test('`usecase` should be called if deps has changed', () => {
-            let i = 0;
-            const mockUseCase = jest.fn(mathUseCase);
-            const { rerender } = renderHook(() => {
-                return useUseCase(mockUseCase, {}, [i++, 'x']);
-            });
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
-            rerender();
-            expect(mockUseCase).toHaveBeenCalledTimes(2);
-        });
-        test('reducer call should not be cached if component is at rendering phase', () => {
-            const buttonText = 'button';
-            const CacheTestComponent = () => {
-                const { subtraction } = useUseCase(mathUseCase);
-                const update = useUpdate();
-                const onClick = () => {
-                    update();
-                };
-                subtraction(5, 3);
-                return _jsx("button", { onClick: onClick, children: buttonText });
+        test('multiple `Provider` should work', () => {
+            const onNumberMount = jest.fn();
+            const onStringMount = jest.fn();
+            const onBooleanMount = jest.fn();
+            const numberUseCase = () => {
+                return objectUseCase();
             };
-            render(_jsx(CacheTestComponent, {}));
-            expect(subtractionReducer).toHaveBeenCalledTimes(1);
-            expect(subtractionReducer).toHaveBeenCalledWith(5, 3);
-            expect(subtractionReducer).toHaveReturnedWith(2);
-            fireEvent.click(screen.getByText(buttonText));
-            expect(subtractionReducer).toHaveBeenCalledTimes(2);
-            fireEvent.click(screen.getByText(buttonText));
-            expect(subtractionReducer).toHaveBeenCalledTimes(3);
-        });
-        test('reducer call should not be cached if component is not at rendering phase', () => {
-            const buttonText = 'button';
-            const CacheTestComponent = () => {
-                const { subtraction } = useUseCase(mathUseCase);
-                const onClick = () => {
-                    subtraction(5, 3);
-                };
+            const stringUseCase = () => {
+                return objectUseCase();
+            };
+            const booleanUseCase = () => {
+                return objectUseCase();
+            };
+            const TestChildComponent = () => {
+                const [numberValue] = useUseCase(numberUseCase);
+                const [stringValue] = useUseCase(stringUseCase);
+                const [booleanValue] = useUseCase(booleanUseCase);
                 useMount(() => {
-                    subtraction(5, 3);
-                    subtraction(5, 3);
+                    onNumberMount(numberValue);
+                    onStringMount(stringValue);
+                    onBooleanMount(booleanValue);
                 });
-                return _jsx("button", { onClick: onClick, children: buttonText });
+                return null;
             };
-            render(_jsx(CacheTestComponent, {}));
-            expect(subtractionReducer).toHaveBeenCalledTimes(2);
-            expect(subtractionReducer).toHaveBeenNthCalledWith(1, 5, 3);
-            expect(subtractionReducer).toHaveNthReturnedWith(1, 2);
-            expect(subtractionReducer).toHaveBeenNthCalledWith(2, 5, 3);
-            expect(subtractionReducer).toHaveNthReturnedWith(2, 2);
-            fireEvent.click(screen.getByText(buttonText));
-            expect(subtractionReducer).toHaveBeenCalledTimes(3);
-            expect(subtractionReducer).toHaveBeenNthCalledWith(3, 5, 3);
-            expect(subtractionReducer).toHaveNthReturnedWith(3, 2);
-        });
-        test('reducer call should not be cached if parameters have changed', () => {
-            let count = 0;
-            const buttonText = 'button';
-            const StringUseCaseTestComponent = () => {
-                const { subtraction } = useUseCase(mathUseCase);
-                const update = useUpdate();
-                subtraction(5, count++);
-                const onUpdate = () => {
-                    update();
-                };
-                return (_jsx("div", { children: _jsx("button", { onClick: onUpdate, children: buttonText }) }));
+            const TestParentComponent = () => {
+                const [, , NumberProvider] = useUseCase(11, numberUseCase);
+                const [, , StringProvider] = useUseCase('hello', stringUseCase);
+                const [, , BooleanProvider] = useUseCase(true, booleanUseCase);
+                return (_jsx(NumberProvider, { with: [StringProvider, BooleanProvider], children: _jsx(TestChildComponent, {}) }));
             };
-            render(_jsx(StringUseCaseTestComponent, {}));
-            expect(subtractionReducer).toHaveBeenCalledTimes(1);
-            expect(subtractionReducer).toHaveBeenCalledWith(5, 0);
-            fireEvent.click(screen.getByText(buttonText));
-            expect(subtractionReducer).toHaveBeenCalledTimes(2);
-            expect(subtractionReducer).toHaveBeenCalledWith(5, 1);
-            expect(subtractionReducer).toHaveReturnedWith(4);
-        });
-        test('`options.extraValue` should be added after call `add` method', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase, { extraValue: 5 });
-            });
-            const { current: reducers } = result;
-            const { add } = reducers;
-            expect(add(1, 2)).toBe(8);
-        });
-        test('when `options` has changed, it should not trigger update', () => {
-            const onUpdate = jest.fn();
-            const onDeepUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                const [extraValue, setExtraValue] = useState(0);
-                const reducers = useUseCase(mathUseCase, { extraValue });
-                useUpdateEffect(() => {
-                    onUpdate();
-                }, [reducers]);
-                useDeepCompareUpdate(() => {
-                    onDeepUpdate();
-                }, [reducers]);
-                return setExtraValue;
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-            act(() => {
-                result.current(3);
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-        });
-        test('when `deps` change, it should update reducers', () => {
-            const onUpdate = jest.fn();
-            const onDeepUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                const [extraValue, setExtraValue] = useState(0);
-                const reducers = useUseCase(mathUseCase, { extraValue }, [extraValue]);
-                useUpdateEffect(() => {
-                    onUpdate();
-                }, [reducers]);
-                useDeepCompareUpdate(() => {
-                    onDeepUpdate();
-                }, [reducers]);
-                return setExtraValue;
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-            act(() => {
-                result.current(3);
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(1);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(1);
-        });
-        test('empty `deps` should not update reducers', () => {
-            const onUpdate = jest.fn();
-            const onDeepUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                const [extraValue, setExtraValue] = useState(0);
-                const reducers = useUseCase(mathUseCase, { extraValue }, []);
-                useUpdateEffect(() => {
-                    onUpdate();
-                }, [reducers]);
-                useDeepCompareUpdate(() => {
-                    onDeepUpdate();
-                }, [reducers]);
-                return setExtraValue;
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-            act(() => {
-                result.current(3);
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-        });
-        test('should not trigger update', () => {
-            const onUpdate = jest.fn();
-            render(_jsx(MathParent, { onUpdate: onUpdate }));
-            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
-            expect(onUpdate).toHaveBeenCalledTimes(0);
+            render(_jsx(TestParentComponent, {}));
+            expect(onNumberMount).toHaveBeenCalledWith(11);
+            expect(onStringMount).toHaveBeenCalledWith('hello');
+            expect(onBooleanMount).toHaveBeenCalledWith(true);
         });
     });
-    describe('`useUseCase` should work with 1+ arguments on context mode', () => {
-        test('should work within <Child /> which it is under <Parent />', () => {
-            const textPrefix = '>>';
-            const onUpdate = jest.fn();
+    describe('`useUseCase` should work the same as useContextualCoreCollection', () => {
+        test.each([void 0, UseCaseModes.Normal])('[mode=%s]: normal mode should trigger Parent & Child to update', (mode) => {
+            const onParentUpdate = jest.fn();
+            const onChildUpdate = jest.fn();
             const onPathChange = jest.fn();
             const onUndefinedEntity = jest.fn();
             const onSetPath = jest.fn(() => {
                 return PATH_1;
             });
-            render(_jsx("div", { children: _jsx(Parent, { onSetPath: onSetPath, children: _jsx(Child, { textPrefix: textPrefix, onUpdate: onUpdate, onPathChange: onPathChange, onUndefinedEntity: onUndefinedEntity }) }) }));
+            render(_jsx("div", { children: _jsx(Parent, { mode: mode, onSetPath: onSetPath, onUpdate: onParentUpdate, children: _jsx(Child, { onUpdate: onChildUpdate, onPathChange: onPathChange, onUndefinedEntity: onUndefinedEntity }) }) }));
             fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
             expect(onSetPath).toHaveBeenCalledTimes(1);
-            expect(onUpdate).toHaveBeenCalledTimes(1);
+            expect(onParentUpdate).toHaveBeenCalledTimes(1);
+            expect(onChildUpdate).toHaveBeenCalledTimes(1);
             expect(onPathChange).toHaveBeenCalledWith(PATH_1);
-            fireEvent.click(screen.getByText(textPrefix + CHILD_BUTTON_TEXT));
+            fireEvent.click(screen.getByText(CHILD_BUTTON_TEXT));
             expect(onSetPath).toHaveBeenCalledTimes(1);
-            expect(onUpdate).toHaveBeenCalledTimes(2);
-            expect(onPathChange).toHaveBeenCalledWith('');
+            expect(onParentUpdate).toHaveBeenCalledTimes(2);
+            expect(onChildUpdate).toHaveBeenCalledTimes(2);
+            expect(onPathChange).toHaveBeenCalledWith(PATH_2);
             expect(onUndefinedEntity).toHaveBeenCalledTimes(0);
         });
+        test.each([UseCaseModes.Stateless, UseCaseModes.StatelessGlobal])('[mode=%s]: stateless mode should not trigger Parent & Child to update', () => {
+            const onParentUpdate = jest.fn();
+            const onChildUpdate = jest.fn();
+            const onSetPath = jest.fn(() => {
+                return PATH_1;
+            });
+            render(_jsx("div", { children: _jsx(Parent, { mode: UseCaseModes.Stateless, onSetPath: onSetPath, onUpdate: onParentUpdate, children: _jsx(Child, { onUpdate: onChildUpdate }) }) }));
+            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
+            expect(onSetPath).toHaveBeenCalledTimes(1);
+            expect(onParentUpdate).toHaveBeenCalledTimes(0);
+            expect(onChildUpdate).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(CHILD_BUTTON_TEXT));
+            expect(onSetPath).toHaveBeenCalledTimes(1);
+            expect(onParentUpdate).toHaveBeenCalledTimes(0);
+            expect(onChildUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('global mode should trigger Parent to update, but Child shoud not be updated', () => {
+            const onParentUpdate = jest.fn();
+            const onChildUpdate = jest.fn();
+            const onSetPath = jest.fn(() => {
+                return PATH_1;
+            });
+            render(_jsx("div", { children: _jsx(Parent, { mode: UseCaseModes.Global, onSetPath: onSetPath, onUpdate: onParentUpdate, children: _jsx(Child, { onUpdate: onChildUpdate }) }) }));
+            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
+            expect(onSetPath).toHaveBeenCalledTimes(1);
+            expect(onParentUpdate).toHaveBeenCalledTimes(1);
+            expect(onChildUpdate).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(CHILD_BUTTON_TEXT));
+            expect(onSetPath).toHaveBeenCalledTimes(1);
+            expect(onParentUpdate).toHaveBeenCalledTimes(2);
+            expect(onChildUpdate).toHaveBeenCalledTimes(0);
+        });
         test('`usecase` should not be called at child component', () => {
             const mockUseCase = jest.fn(fileUseCase);
             const A = () => {
@@ -1521,4 +1403,193 @@ describe('useUseCase', () => {
             expect(onChangeC).toHaveReturnedWith(3);
         });
     });
+    describe('`useUseCase` should work the same as `useReducers`', () => {
+        test('`entity` should equal `defaultFile`', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(mathUseCase);
+            });
+            const { current: reducers } = result;
+            expect(Array.isArray(reducers)).toBe(false);
+        });
+        test('returned reducer should work', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(mathUseCase);
+            });
+            const { current: reducers } = result;
+            const { add } = reducers;
+            expect(add(1, 2)).toBe(3);
+        });
+        test('`usecase` should be called only once if deps has not provided', () => {
+            const mockUseCase = jest.fn(mathUseCase);
+            const { rerender } = renderHook(() => {
+                return useUseCase(mockUseCase);
+            });
+            expect(mockUseCase).toHaveBeenCalledTimes(1);
+            rerender();
+            expect(mockUseCase).toHaveBeenCalledTimes(1);
+        });
+        test('`usecase` should be called only once if deps has not changed', () => {
+            const mockUseCase = jest.fn(mathUseCase);
+            const { rerender } = renderHook(() => {
+                return useUseCase(mockUseCase, {}, [1, 'x']);
+            });
+            expect(mockUseCase).toHaveBeenCalledTimes(1);
+            rerender();
+            expect(mockUseCase).toHaveBeenCalledTimes(1);
+        });
+        test('`usecase` should be called if deps has changed', () => {
+            let i = 0;
+            const mockUseCase = jest.fn(mathUseCase);
+            const { rerender } = renderHook(() => {
+                return useUseCase(mockUseCase, {}, [i++, 'x']);
+            });
+            expect(mockUseCase).toHaveBeenCalledTimes(1);
+            rerender();
+            expect(mockUseCase).toHaveBeenCalledTimes(2);
+        });
+        test('reducer call should not be cached if component is at rendering phase', () => {
+            const buttonText = 'button';
+            const CacheTestComponent = () => {
+                const { subtraction } = useUseCase(mathUseCase);
+                const update = useUpdate();
+                const onClick = () => {
+                    update();
+                };
+                subtraction(5, 3);
+                return _jsx("button", { onClick: onClick, children: buttonText });
+            };
+            render(_jsx(CacheTestComponent, {}));
+            expect(subtractionReducer).toHaveBeenCalledTimes(1);
+            expect(subtractionReducer).toHaveBeenCalledWith(5, 3);
+            expect(subtractionReducer).toHaveReturnedWith(2);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(subtractionReducer).toHaveBeenCalledTimes(2);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(subtractionReducer).toHaveBeenCalledTimes(3);
+        });
+        test('reducer call should not be cached if component is not at rendering phase', () => {
+            const buttonText = 'button';
+            const CacheTestComponent = () => {
+                const { subtraction } = useUseCase(mathUseCase);
+                const onClick = () => {
+                    subtraction(5, 3);
+                };
+                useMount(() => {
+                    subtraction(5, 3);
+                    subtraction(5, 3);
+                });
+                return _jsx("button", { onClick: onClick, children: buttonText });
+            };
+            render(_jsx(CacheTestComponent, {}));
+            expect(subtractionReducer).toHaveBeenCalledTimes(2);
+            expect(subtractionReducer).toHaveBeenNthCalledWith(1, 5, 3);
+            expect(subtractionReducer).toHaveNthReturnedWith(1, 2);
+            expect(subtractionReducer).toHaveBeenNthCalledWith(2, 5, 3);
+            expect(subtractionReducer).toHaveNthReturnedWith(2, 2);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(subtractionReducer).toHaveBeenCalledTimes(3);
+            expect(subtractionReducer).toHaveBeenNthCalledWith(3, 5, 3);
+            expect(subtractionReducer).toHaveNthReturnedWith(3, 2);
+        });
+        test('reducer call should not be cached if parameters have changed', () => {
+            let count = 0;
+            const buttonText = 'button';
+            const StringUseCaseTestComponent = () => {
+                const { subtraction } = useUseCase(mathUseCase);
+                const update = useUpdate();
+                subtraction(5, count++);
+                const onUpdate = () => {
+                    update();
+                };
+                return (_jsx("div", { children: _jsx("button", { onClick: onUpdate, children: buttonText }) }));
+            };
+            render(_jsx(StringUseCaseTestComponent, {}));
+            expect(subtractionReducer).toHaveBeenCalledTimes(1);
+            expect(subtractionReducer).toHaveBeenCalledWith(5, 0);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(subtractionReducer).toHaveBeenCalledTimes(2);
+            expect(subtractionReducer).toHaveBeenCalledWith(5, 1);
+            expect(subtractionReducer).toHaveReturnedWith(4);
+        });
+        test('`options.extraValue` should be added after call `add` method', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(mathUseCase, { extraValue: 5 });
+            });
+            const { current: reducers } = result;
+            const { add } = reducers;
+            expect(add(1, 2)).toBe(8);
+        });
+        test('when `options` has changed, it should not trigger update', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [extraValue, setExtraValue] = useState(0);
+                const reducers = useUseCase(mathUseCase, { extraValue });
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [reducers]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [reducers]);
+                return setExtraValue;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current(3);
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('when `deps` change, it should update reducers', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [extraValue, setExtraValue] = useState(0);
+                const reducers = useUseCase(mathUseCase, { extraValue }, [extraValue]);
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [reducers]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [reducers]);
+                return setExtraValue;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current(3);
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(1);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(1);
+        });
+        test('empty `deps` should not update reducers', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [extraValue, setExtraValue] = useState(0);
+                const reducers = useUseCase(mathUseCase, { extraValue }, []);
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [reducers]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [reducers]);
+                return setExtraValue;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current(3);
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('should not trigger update', () => {
+            const onUpdate = jest.fn();
+            render(_jsx(MathParent, { onUpdate: onUpdate }));
+            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+        });
+    });
 });

package/es/hooks/useUseCase/types.d.ts

@@ -1,7 +1,8 @@
 import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
 import { EntityReducers, EntityUseCase, Reducers, UseCase } from '@mic-rexjs/usecases';
 import { UseCaseProvider } from '../useProvider/types';
-export type CoreCollection<T, TEntityReducers extends EntityReducers<T>, TProvide extends UseCaseProvider | null = UseCaseProvider> = [entity: T, reducers: ContextualEntityReducers<T, TEntityReducers>, Provider: TProvide];
+import { UseCaseModes } from '../../enums/UseCaseModes';
+export type CoreCollection<T, TEntityReducers extends EntityReducers<T>, TProvider extends UseCaseProvider | null = UseCaseProvider> = [entity: T, reducers: ContextualEntityReducers<T, TEntityReducers>, Provider: TProvider];
 export interface EntityGetter<T> {
     (): T;
 }
@@ -28,24 +29,70 @@ export interface UseCaseHookContextualOptions<T> {
     onChange?(newEntity: T, oldEntity: T): void;
 }
 export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extends UseCaseHookContextualOptions<T> {
-    stateless?: boolean;
     options?: TUseCaseOptions;
 }
 export type UseCaseHookOptions<T, TUseCaseOptions extends object = object> = TUseCaseOptions & UseCaseHookOwnOptions<T, TUseCaseOptions>;
-export interface UseCaseHook {
-    <T, TEntityReducers extends EntityReducers<T>>(usecase: EntityUseCase<T, TEntityReducers> & 
+export type ContextualCoreCollectionHookParameters<T, TEntityReducers extends EntityReducers<T>> = [
+    usecase: EntityUseCase<T, TEntityReducers> & 
     /**
      * 如果不使用 `&`，那么很多情况下 `options` 类型无法被正确推导；
      * 因为使用 `&` 是为了让该参数 `usecase` 的泛型 `T` 推导占优先级，
      * 从而保证 `options` 里的泛型 `T` 是根据 `usecase` 来推导的。
      */
-    UseCase<EntityReducers<T>>, options?: UseCaseHookContextualOptions<T>): CoreCollection<T, TEntityReducers, null>;
-    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(initailEntity: T | EntityGetter<T>, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & 
+    UseCase<EntityReducers<T>>,
+    options?: UseCaseHookContextualOptions<T>
+];
+export interface ContextualCoreCollectionHook {
+    <T, TEntityReducers extends EntityReducers<T>>(...args: ContextualCoreCollectionHookParameters<T, TEntityReducers>): CoreCollection<T, TEntityReducers, null>;
+}
+export type RootCoreCollectionHookParameters<T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object> = [
+    entity: T | EntityGetter<T>,
+    usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & 
+    /**
+     * 如果不使用 `&`，那么很多情况下 `options` 类型无法被正确推导；
+     * 因为使用 `&` 是为了让该参数 `usecase` 的泛型 `T` 推导占优先级，
+     * 从而保证 `options` 里的泛型 `T` 是根据 `usecase` 来推导的。
+     */
+    UseCase<EntityReducers<T>, TUseCaseOptions>,
+    options?: UseCaseHookOptions<T, TUseCaseOptions>,
+    deps?: unknown[]
+];
+export interface RootCoreCollectionHook {
+    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(...args: RootCoreCollectionHookParameters<T, TEntityReducers, TUseCaseOptions>): CoreCollection<T, TEntityReducers>;
+}
+export type ModeCoreCollectionHookParameters<T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object> = [
+    entity: T | EntityGetter<T>,
+    usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & 
     /**
      * 如果不使用 `&`，那么很多情况下 `options` 类型无法被正确推导；
      * 因为使用 `&` 是为了让该参数 `usecase` 的泛型 `T` 推导占优先级，
      * 从而保证 `options` 里的泛型 `T` 是根据 `usecase` 来推导的。
      */
-    UseCase<EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): CoreCollection<T, TEntityReducers>;
-    <T extends Reducers, TUseCaseOptions extends object = object>(usecase: UseCase<T, TUseCaseOptions>, options?: TUseCaseOptions, deps?: unknown[]): T;
+    UseCase<EntityReducers<T>, TUseCaseOptions>,
+    mode?: UseCaseModes,
+    options?: UseCaseHookOptions<T, TUseCaseOptions>,
+    deps?: unknown[]
+];
+export interface ModeCoreCollectionHook {
+    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(...args: ModeCoreCollectionHookParameters<T, TEntityReducers, TUseCaseOptions>): CoreCollection<T, TEntityReducers>;
+}
+export interface CoreCollectionHook extends ContextualCoreCollectionHook, RootCoreCollectionHook, ModeCoreCollectionHook {
+}
+export type ReducersHookParameters<T extends Reducers, TUseCaseOptions extends object = object> = [
+    usecase: UseCase<T, TUseCaseOptions>,
+    options?: TUseCaseOptions,
+    deps?: unknown[]
+];
+export interface ReducersHook {
+    <T extends Reducers, TUseCaseOptions extends object = object>(...args: ReducersHookParameters<T, TUseCaseOptions>): T;
+}
+export type UseCaseHookParameters<T, TReducers extends Reducers, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object> = ContextualCoreCollectionHookParameters<T, TEntityReducers> | RootCoreCollectionHookParameters<T, TEntityReducers, TUseCaseOptions> | ModeCoreCollectionHookParameters<T, TEntityReducers, TUseCaseOptions> | ReducersHookParameters<TReducers, TUseCaseOptions>;
+export type UseCaseHookMaxParameters<T, TReducers extends Reducers, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object> = [
+    entity: T | EntityGetter<T> | null,
+    usecase: UseCase<TReducers, TUseCaseOptions> | EntityUseCase<T, TEntityReducers, TUseCaseOptions>,
+    mode: UseCaseModes,
+    options: TUseCaseOptions | UseCaseHookOptions<T, TUseCaseOptions> | UseCaseHookContextualOptions<T>,
+    deps: unknown[]
+];
+export interface UseCaseHook extends CoreCollectionHook, ReducersHook {
 }

package/es/hooks/useUseCaseContext/index.d.ts

@@ -1,3 +1,3 @@
 import { EntityReducers, EntityUseCase } from '@mic-rexjs/usecases';
-import { UseCaseMappingContext } from '../../configs/usecaseContextMap/types';
-export declare const useUseCaseContext: <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object, TContext extends UseCaseMappingContext<T, TEntityReducers, TUseCaseOptions> = UseCaseMappingContext<T, TEntityReducers, TUseCaseOptions>>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>, defaultContext?: TContext | null | undefined) => TContext;
+import { UseCaseContext } from '../../configs/defaultUseCaseContext/types';
+export declare const useUseCaseContext: <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object, TContext extends UseCaseContext<T, TEntityReducers> = UseCaseContext<T, TEntityReducers>>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>, defaultContext?: TContext | null | undefined) => TContext;