@mic-rexjs/usecases-react 1.3.32

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

@@ -0,0 +1,670 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { objectUseCase, } from '@mic-rexjs/usecases';
+import { describe, expect, jest, test } from '@jest/globals';
+import { renderHook, act, render, fireEvent, screen } from '@testing-library/react';
+import { useUseCase } from '.';
+import { useDeepCompareEffect, useMemoizedFn, useUpdate, useUpdateEffect } from 'ahooks';
+import { Fragment, useEffect, useRef, useState } from 'react';
+const EXT_1 = '.png';
+const EXT_2 = '.jpg';
+const PATH_1 = `hello${EXT_1}`;
+const PARENT_BUTTON_TEXT = 'parent button';
+const CHILD_BUTTON_TEXT = 'child button';
+const defaultFile = {
+    path: '',
+    ext: '',
+    size: 0,
+};
+const fileUseCase = (options = {}) => {
+    const entityReducers = objectUseCase();
+    const { pathPrefix = '' } = options;
+    const init = function* (entity, newEntity = defaultFile) {
+        yield () => {
+            return newEntity;
+        };
+    };
+    const setPath = function* (entity, path) {
+        yield {
+            ...entity,
+            path: pathPrefix + path,
+            ext: path.match(/\.[^.]+$/)?.[0] || '',
+        };
+    };
+    const readFile = async function* (entity, path) {
+        const size = 2000;
+        yield* setPath(entity, path);
+        await Promise.resolve(null);
+        yield (prevEntity) => {
+            return {
+                ...prevEntity,
+                size,
+            };
+        };
+        return size;
+    };
+    const isImage = (entity) => {
+        const { ext } = entity;
+        return [EXT_1, EXT_2].includes(ext);
+    };
+    return { ...entityReducers, init, setPath, readFile, isImage };
+};
+const mathUseCase = (options = {}) => {
+    const { extraValue = 0 } = options;
+    const add = (value1, value2) => {
+        return value1 + value2 + extraValue;
+    };
+    const subtraction = (value1, value2) => {
+        return value1 - value2;
+    };
+    return { add, subtraction };
+};
+const Child = ({ textPrefix = '', onUpdate, onPathChange, onUndefinedEntity }) => {
+    const [file, { setPath }] = useUseCase(fileUseCase);
+    const { path, ext } = file || {};
+    const onClick = () => {
+        setPath('');
+    };
+    const undefinedEntity = useMemoizedFn(() => {
+        onUndefinedEntity?.();
+    });
+    useUpdateEffect(() => {
+        onUpdate?.();
+    });
+    useEffect(() => {
+        if (file === void 0) {
+            undefinedEntity();
+        }
+    }, [file, undefinedEntity]);
+    const pathChange = useMemoizedFn(() => {
+        onPathChange?.(path);
+    });
+    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 onClick = () => {
+        setPath(onSetPath?.() || '');
+    };
+    useUpdateEffect(() => {
+        onUpdate?.();
+    });
+    return (_jsx(Provider, { children: _jsxs("div", { children: [_jsxs("header", { children: ["parent path: ", path, _jsx("br", {}), "parent ext: ", ext] }), _jsx("main", { children: children }), _jsx("footer", { children: _jsx("button", { onClick: onClick, children: PARENT_BUTTON_TEXT }) })] }) }));
+};
+const MathParent = ({ extraValue = 0, onUpdate }) => {
+    const { add } = useUseCase(mathUseCase, { extraValue }, [extraValue]);
+    const onClick = () => {
+        add(1, 2);
+    };
+    useUpdateEffect(() => {
+        onUpdate?.();
+    });
+    return (_jsx("div", { children: _jsx("button", { onClick: onClick, children: PARENT_BUTTON_TEXT }) }));
+};
+const useDeepCompareUpdate = (callback, deps) => {
+    const isFirstRef = useRef(true);
+    useEffect(() => {
+        return () => {
+            isFirstRef.current = false;
+        };
+    });
+    useDeepCompareEffect.call(null, () => {
+        if (isFirstRef.current) {
+            return;
+        }
+        callback();
+    }, deps);
+};
+describe('useUseCase', () => {
+    describe('`useUseCase` should work with 2+ arguments on provider mode', () => {
+        test('check `context.length`', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase);
+            });
+            const { current: context } = result;
+            expect(context).toHaveLength(3);
+        });
+        test('`entity` should equal `defaultFile`', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase);
+            });
+            const { current: context } = result;
+            const [entity] = context;
+            expect(entity).toBe(defaultFile);
+        });
+        test('`reducers` should be returned as an object', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase);
+            });
+            const { current: context } = result;
+            const [, reducers] = context;
+            expect(typeof reducers).toBe('object');
+        });
+        test('`Provider` should be returned as a function', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase);
+            });
+            const { current: context } = result;
+            const [, , Provider] = context;
+            expect(typeof Provider).toBe('function');
+        });
+        test('after call non-generator reducer, it should not trigger update', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const context = useUseCase(defaultFile, fileUseCase);
+                const [, reducers] = context;
+                const { isImage } = reducers;
+                const update = useUpdate();
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [context]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [context]);
+                return (shouldUpdate) => {
+                    isImage();
+                    if (!shouldUpdate) {
+                        return;
+                    }
+                    update();
+                };
+            });
+            act(() => {
+                result.current();
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current(true);
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('after `yield entity`, it should trigger update', () => {
+            const onUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                useUpdateEffect(() => {
+                    onUpdate();
+                });
+                return useUseCase(defaultFile, fileUseCase);
+            });
+            const { current: context } = result;
+            const [entity, reducers] = context;
+            const { setPath, setEntity } = reducers;
+            act(() => {
+                setPath(PATH_1);
+                setEntity({ size: 5000 });
+            });
+            expect(result.current).not.toBe(context);
+            expect(result.current[0]).not.toBe(entity);
+            expect(result.current[1]).not.toBe(reducers);
+            expect(result.current[1].setPath).not.toBe(setPath);
+            expect(result.current[0]).toEqual({
+                ...defaultFile,
+                path: PATH_1,
+                ext: EXT_1,
+                size: 5000,
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(1);
+        });
+        test('after `yield entity` on async mode, it should trigger update', async () => {
+            const onUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                useUpdateEffect(() => {
+                    onUpdate();
+                });
+                return useUseCase(defaultFile, fileUseCase);
+            });
+            const { current: context } = result;
+            const [entity, reducers] = context;
+            const { readFile } = reducers;
+            const promise = act(() => {
+                return readFile(PATH_1);
+            });
+            expect(result.current).toBe(context);
+            expect(result.current).toEqual(context);
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            await promise;
+            expect(result.current[0]).not.toBe(entity);
+            expect(result.current[1]).not.toBe(reducers);
+            expect(result.current[1].readFile).not.toBe(readFile);
+            expect(result.current[0].path).toBe(PATH_1);
+            expect(result.current[0].ext).toBe(EXT_1);
+            expect(result.current[0].size).toBe(2000);
+            expect(onUpdate).toHaveBeenCalledTimes(1);
+        });
+        test('after `yield entity` callbacks, it should trigger update', () => {
+            const onUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                useUpdateEffect(() => {
+                    onUpdate();
+                });
+                return useUseCase(defaultFile, fileUseCase);
+            });
+            const { current: context } = result;
+            const [, reducers] = context;
+            const { init } = reducers;
+            act(() => {
+                init({ ...defaultFile, size: 5000 });
+            });
+            expect(result.current[0].size).toBe(5000);
+            expect(result.current[1]).not.toBe(reducers);
+            expect(result.current[1].init).not.toBe(init);
+            expect(onUpdate).toHaveBeenCalledTimes(1);
+        });
+        test('`options.stateless` 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 });
+            });
+            const { current: context } = result;
+            const [, { setPath }] = context;
+            setPath(PATH_1);
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(result.current[0].path).toBe('');
+            expect(result.current[1].setPath).toBe(setPath);
+            rerender({ ...defaultFile, path: PATH_1 });
+            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`', () => {
+            const onUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                useUpdateEffect(() => {
+                    onUpdate();
+                });
+                return useUseCase(defaultFile, fileUseCase, { stateless: true });
+            });
+            const { current: context } = result;
+            const [, reducers] = context;
+            const { setPath } = reducers;
+            act(() => {
+                setPath(PATH_1);
+            });
+            expect(result.current).toBe(context);
+            expect(result.current).toEqual(context);
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('`options.onChange` should be trigger when entity has changed', () => {
+            const onChange = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, { onChange });
+            });
+            const { current: context } = result;
+            const [, reducers] = context;
+            const { setPath } = reducers;
+            expect(onChange).toHaveBeenCalledTimes(0);
+            act(() => {
+                setPath(PATH_1);
+            });
+            expect(onChange).toHaveBeenCalledTimes(1);
+            expect(onChange).toHaveBeenLastCalledWith({ ...defaultFile, path: PATH_1, ext: EXT_1 }, defaultFile);
+        });
+        test('`options.options` should override rest options', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, {
+                    pathPrefix: 'xyz/',
+                    options: { pathPrefix: '123/' },
+                });
+            });
+            const { current: context } = result;
+            const [{ path }, reducers] = context;
+            const { setPath } = reducers;
+            expect(path).toBe('');
+            act(() => {
+                setPath(PATH_1);
+            });
+            expect(result.current[0].path).toBe('123/' + PATH_1);
+        });
+        test('when `options` has changed, it should not trigger update', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [pathPrefix, setPathPrefix] = useState('user/');
+                const context = useUseCase(defaultFile, fileUseCase, { pathPrefix });
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [context]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [context]);
+                return setPathPrefix;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current('my/');
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('when `entity` change, it should trigger watchers', () => {
+            const onPathChange1 = jest.fn();
+            const onPathChange2 = jest.fn();
+            let onPathChange = onPathChange1;
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, {
+                    watch: {
+                        path: onPathChange,
+                    },
+                });
+            });
+            const { current: context } = result;
+            const [, { setPath, setEntity }] = context;
+            onPathChange = onPathChange2;
+            expect(onPathChange1).toHaveBeenCalledTimes(0);
+            act(() => {
+                setPath(PATH_1);
+                setEntity({ size: 5000 });
+            });
+            expect(onPathChange1).toHaveBeenCalledTimes(1);
+            expect(onPathChange1).toHaveBeenLastCalledWith({ ...defaultFile, path: PATH_1, ext: EXT_1 }, defaultFile);
+            act(() => {
+                setPath('');
+            });
+            expect(onPathChange2).toHaveBeenCalledTimes(1);
+            expect(onPathChange2).toHaveBeenLastCalledWith({ ...defaultFile, size: 5000 }, { ...defaultFile, path: PATH_1, size: 5000, ext: EXT_1 });
+        });
+        test('when `deps` has changed, it should trigger update', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [pathPrefix, setPathPrefix] = useState('user/');
+                const context = useUseCase(defaultFile, fileUseCase, { pathPrefix }, [pathPrefix]);
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [context]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [context]);
+                return setPathPrefix;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current('my/');
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(1);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(1);
+        });
+        test('empty `deps` should not trigger update', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [pathPrefix, setPathPrefix] = useState('user/');
+                const context = useUseCase(defaultFile, fileUseCase, { pathPrefix }, []);
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [context]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [context]);
+                return setPathPrefix;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current('my/');
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+        });
+    });
+    describe('`useUseCase` should work with 1+ argument on accessor mode', () => {
+        test('check `context.length`', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(fileUseCase);
+            });
+            const { current: context } = result;
+            expect(context).toHaveLength(2);
+        });
+        test('`entity` should be `undefined`', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(fileUseCase);
+            });
+            const { current: context } = result;
+            const [entity] = context;
+            expect(entity).toBe(void 0);
+        });
+        test('`reducers` should be returned as an object', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(fileUseCase);
+            });
+            const { current: context } = result;
+            const [, reducers] = context;
+            expect(typeof reducers).toBe('object');
+        });
+        test('`yield entity` should not trigger update', () => {
+            const onUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                useUpdateEffect(() => {
+                    onUpdate();
+                });
+                return useUseCase(fileUseCase);
+            });
+            const { current: context } = result;
+            const [, reducers] = context;
+            const { setPath } = reducers;
+            act(() => {
+                setPath(PATH_1);
+            });
+            expect(result.current).toBe(context);
+            expect(result.current).toEqual(context);
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('should work within <Child />', () => {
+            const textPrefix = '>>';
+            const onUpdate1 = jest.fn();
+            const onPathChange1 = jest.fn();
+            const onUndefinedEntity1 = jest.fn();
+            const onUpdate2 = jest.fn();
+            const onPathChange2 = jest.fn();
+            const onUndefinedEntity2 = jest.fn();
+            const onSetPath = jest.fn(() => {
+                return PATH_1;
+            });
+            render(_jsxs("div", { children: [_jsx(Parent, { onSetPath: onSetPath, children: _jsx(Child, { textPrefix: textPrefix, onUpdate: onUpdate1, onPathChange: onPathChange1, onUndefinedEntity: onUndefinedEntity1 }) }), _jsx(Child, { onUpdate: onUpdate2, onPathChange: onPathChange2, onUndefinedEntity: onUndefinedEntity2 })] }));
+            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
+            expect(onSetPath).toHaveBeenCalledTimes(1);
+            expect(onUpdate1).toHaveBeenCalledTimes(1);
+            expect(onPathChange1).toHaveBeenCalledWith(PATH_1);
+            fireEvent.click(screen.getByText(textPrefix + CHILD_BUTTON_TEXT));
+            expect(onSetPath).toHaveBeenCalledTimes(1);
+            expect(onUpdate1).toHaveBeenCalledTimes(2);
+            expect(onPathChange1).toHaveBeenCalledWith('');
+            expect(onUpdate2).toHaveBeenCalledTimes(0);
+            expect(onPathChange2).toHaveBeenCalledTimes(0);
+            expect(onUndefinedEntity1).toHaveBeenCalledTimes(0);
+            expect(onUndefinedEntity2).toHaveBeenCalledTimes(1);
+        });
+        test('`options.onChange` event should be trigger at child elements', () => {
+            const onFirstChange = jest.fn();
+            const onSecondChange = jest.fn();
+            const onParentPathChange = jest.fn();
+            const firstButtonText = 'first button';
+            const secondButtonText = 'second button';
+            let onChange = onFirstChange;
+            const A = () => {
+                useUseCase(fileUseCase, { onChange });
+                return _jsx(Fragment, {});
+            };
+            const B = () => {
+                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
+                    onChange: onParentPathChange,
+                });
+                const onFirstClick = () => {
+                    setPath(PATH_1);
+                    onChange = onSecondChange;
+                };
+                const onSecondClick = () => {
+                    setPath('');
+                };
+                return (_jsxs(Provider, { children: [_jsx(A, {}), _jsx("button", { onClick: onFirstClick, children: firstButtonText }), _jsx("button", { onClick: onSecondClick, children: secondButtonText })] }));
+            };
+            render(_jsx(B, {}));
+            expect(onFirstChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(firstButtonText));
+            expect(onFirstChange).toHaveBeenCalledTimes(1);
+            expect(onFirstChange).toHaveBeenLastCalledWith({ ...defaultFile, ext: EXT_1, path: PATH_1 }, defaultFile);
+            expect(onParentPathChange).toHaveBeenCalledTimes(1);
+            expect(onSecondChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(secondButtonText));
+            expect(onSecondChange).toHaveBeenCalledTimes(1);
+            expect(onSecondChange).toHaveBeenLastCalledWith(defaultFile, {
+                ...defaultFile,
+                ext: EXT_1,
+                path: PATH_1,
+            });
+            expect(onFirstChange).toHaveBeenCalledTimes(1);
+            expect(onParentPathChange).toHaveBeenCalledTimes(2);
+        });
+        test('`options.watch` should be trigger at child elements', () => {
+            const onFirstExtChange = jest.fn();
+            const onSecondExtChange = jest.fn();
+            const onParentExtChange = jest.fn();
+            let onExtChange = onFirstExtChange;
+            const firstButtonText = 'first button';
+            const secondButtonText = 'second button';
+            const A = () => {
+                useUseCase(fileUseCase, {
+                    watch: {
+                        ext: onExtChange,
+                    },
+                });
+                return _jsx(Fragment, {});
+            };
+            const B = () => {
+                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
+                    watch: {
+                        ext: onParentExtChange,
+                    },
+                });
+                const onFirstClick = () => {
+                    setPath(PATH_1);
+                    onExtChange = onSecondExtChange;
+                };
+                const onSecondClick = () => {
+                    setPath('');
+                };
+                return (_jsxs(Provider, { children: [_jsx(A, {}), _jsx("button", { onClick: onFirstClick, children: firstButtonText }), _jsx("button", { onClick: onSecondClick, children: secondButtonText })] }));
+            };
+            render(_jsx(B, {}));
+            expect(onFirstExtChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(firstButtonText));
+            expect(onFirstExtChange).toHaveBeenCalledTimes(1);
+            expect(onFirstExtChange).toHaveBeenLastCalledWith({ ...defaultFile, ext: EXT_1, path: PATH_1 }, defaultFile);
+            expect(onParentExtChange).toHaveBeenCalledTimes(1);
+            expect(onSecondExtChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(secondButtonText));
+            expect(onSecondExtChange).toHaveBeenCalledTimes(1);
+            expect(onSecondExtChange).toHaveBeenLastCalledWith(defaultFile, {
+                ...defaultFile,
+                ext: EXT_1,
+                path: PATH_1,
+            });
+            expect(onFirstExtChange).toHaveBeenCalledTimes(1);
+            expect(onParentExtChange).toHaveBeenCalledTimes(2);
+        });
+    });
+    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(typeof reducers).toBe('object');
+        });
+        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('`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/methods/triggerCallbacks/index.d.ts

@@ -0,0 +1,3 @@
+import { OptionsGetter } from '../../../../core/usecases/optionsGetterCellectionUseCase/types';
+import { UseCaseHookOptions } from '../../types';
+export declare const triggerCallbacks: <T, TOptions extends object>(getterList: OptionsGetter<UseCaseHookOptions<T, TOptions>>[], newEntity: T, prevEntity: T) => void;

package/es/hooks/useUseCase/methods/triggerCallbacks/index.js

@@ -0,0 +1,11 @@
+import { triggerWatchers } from '../triggerWatchers';
+export const triggerCallbacks = (getterList, newEntity, prevEntity) => {
+    for (const getter of getterList) {
+        const { onChange, watch } = getter();
+        onChange?.(newEntity, prevEntity);
+        if (!watch) {
+            continue;
+        }
+        triggerWatchers(watch, newEntity, prevEntity);
+    }
+};

package/es/hooks/useUseCase/methods/triggerWatchers/index.d.ts

@@ -0,0 +1,2 @@
+import { EntityWatchMap } from '../../types';
+export declare const triggerWatchers: <T>(watch: EntityWatchMap<T>, newEntity: T, prevEntity: T) => void;