@mic-rexjs/usecases-react 2.3.4 → 2.3.6

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

@@ -63,6 +63,9 @@ const mathUseCase = (options = {}) => {
     };
     return { add, subtraction: subtractionReducer };
 };
+const fieldPathUseCase = () => {
+    return objectUseCase();
+};
 const Child = ({ textPrefix = '', onUpdate, onPathChange, onUndefinedEntity }) => {
     const [file, { setPath }] = useUseCase(fileUseCase);
     const { path, ext } = file || {};
@@ -558,6 +561,475 @@ describe('useUseCase', () => {
             expect(onPathChange2).toHaveBeenCalledTimes(1);
             expect(onPathChange2).toHaveBeenLastCalledWith(PATH_2, PATH_1);
         });
+        test('`options.watch` should be trigger after entity changed', () => {
+            const onPathChange = jest.fn();
+            const onSizeChange = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, {
+                    watch: {
+                        path: onPathChange,
+                        size: onSizeChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setPath }] = cores;
+            expect(onPathChange).toHaveBeenCalledTimes(0);
+            act(() => {
+                setPath(PATH_1);
+            });
+            expect(onPathChange).toHaveBeenCalledTimes(1);
+            expect(onSizeChange).toHaveBeenCalledTimes(0);
+            expect(onPathChange).toHaveBeenLastCalledWith({
+                fieldPaths: ['path'],
+                newEntity: { ...defaultFile, path: PATH_1, ext: EXT_1 },
+                oldEntity: defaultFile,
+                newValue: PATH_1,
+                oldValue: '',
+            });
+        });
+        test('`options.watch` should trigger the latest one', () => {
+            const onPathChange1 = jest.fn();
+            const onPathChange2 = jest.fn();
+            let onPathChange = onPathChange1;
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, {
+                    watch: {
+                        path: onPathChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setPath, setEntity }] = cores;
+            expect(onPathChange1).toHaveBeenCalledTimes(0);
+            act(() => {
+                setPath(PATH_1);
+                setEntity({ size: 5000 });
+                onPathChange = onPathChange2;
+            });
+            expect(onPathChange1).toHaveBeenCalledTimes(1);
+            expect(onPathChange1).toHaveBeenLastCalledWith({
+                fieldPaths: ['path'],
+                newEntity: { ...defaultFile, path: PATH_1, ext: EXT_1 },
+                oldEntity: defaultFile,
+                newValue: PATH_1,
+                oldValue: '',
+            });
+            act(() => {
+                setPath('');
+            });
+            expect(onPathChange1).toHaveBeenCalledTimes(1);
+            expect(onPathChange2).toHaveBeenCalledTimes(1);
+            expect(onPathChange2).toHaveBeenLastCalledWith({
+                fieldPaths: ['path'],
+                newEntity: { ...defaultFile, size: 5000 },
+                oldEntity: { ...defaultFile, path: PATH_1, ext: EXT_1, size: 5000 },
+                newValue: '',
+                oldValue: PATH_1,
+            });
+        });
+        test('`options.watch` should work with array field path of array', () => {
+            const onExtChange = jest.fn();
+            const onSizeChange = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase({}, fieldPathUseCase, {
+                    watch: {
+                        'list.ext': onExtChange,
+                        'list.size': onSizeChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setEntity }] = cores;
+            act(() => {
+                setEntity({ list: [defaultFile] });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(1);
+            expect(onSizeChange).toHaveBeenCalledTimes(1);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '0', 'ext'],
+                newEntity: { list: [defaultFile] },
+                oldEntity: {},
+                newValue: '',
+                oldValue: void 0,
+            });
+            expect(onSizeChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '0', 'size'],
+                newEntity: { list: [defaultFile] },
+                oldEntity: {},
+                newValue: 0,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity({ list: [{ ...defaultFile, ext: EXT_1 }] });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(2);
+            expect(onSizeChange).toHaveBeenCalledTimes(1);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '0', 'ext'],
+                newEntity: { list: [{ ...defaultFile, ext: EXT_1 }] },
+                oldEntity: { list: [defaultFile] },
+                newValue: EXT_1,
+                oldValue: '',
+            });
+            act(() => {
+                setEntity({
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(3);
+            expect(onSizeChange).toHaveBeenCalledTimes(2);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '1', 'ext'],
+                newEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                },
+                oldEntity: { list: [{ ...defaultFile, ext: EXT_1 }] },
+                newValue: EXT_2,
+                oldValue: void 0,
+            });
+            expect(onSizeChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '1', 'size'],
+                newEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                },
+                oldEntity: { list: [{ ...defaultFile, ext: EXT_1 }] },
+                newValue: 0,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity({
+                    nestedList: [],
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(3);
+            expect(onSizeChange).toHaveBeenCalledTimes(2);
+            act(() => {
+                setEntity(() => {
+                    return {
+                        list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                    };
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(6);
+            expect(onSizeChange).toHaveBeenCalledTimes(3);
+            expect(onExtChange).toHaveBeenNthCalledWith(4, {
+                fieldPaths: ['list', '0', 'ext'],
+                newEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                oldEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                    nestedList: [],
+                },
+                newValue: EXT_2,
+                oldValue: EXT_1,
+            });
+            expect(onExtChange).toHaveBeenNthCalledWith(5, {
+                fieldPaths: ['list', '1', 'ext'],
+                newEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                oldEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                    nestedList: [],
+                },
+                newValue: EXT_1,
+                oldValue: EXT_2,
+            });
+            expect(onExtChange).toHaveBeenNthCalledWith(6, {
+                fieldPaths: ['list', '2', 'ext'],
+                newEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                oldEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                    nestedList: [],
+                },
+                newValue: '',
+                oldValue: void 0,
+            });
+            expect(onSizeChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '2', 'size'],
+                newEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                oldEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                    nestedList: [],
+                },
+                newValue: 0,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity(() => {
+                    return {};
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(9);
+            expect(onSizeChange).toHaveBeenCalledTimes(6);
+            expect(onExtChange).toHaveBeenNthCalledWith(7, {
+                fieldPaths: ['list', '0', 'ext'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: EXT_2,
+            });
+            expect(onExtChange).toHaveBeenNthCalledWith(8, {
+                fieldPaths: ['list', '1', 'ext'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: EXT_1,
+            });
+            expect(onExtChange).toHaveBeenNthCalledWith(9, {
+                fieldPaths: ['list', '2', 'ext'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: '',
+            });
+            expect(onSizeChange).toHaveBeenNthCalledWith(4, {
+                fieldPaths: ['list', '0', 'size'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: 0,
+            });
+            expect(onSizeChange).toHaveBeenNthCalledWith(5, {
+                fieldPaths: ['list', '1', 'size'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: 0,
+            });
+            expect(onSizeChange).toHaveBeenNthCalledWith(6, {
+                fieldPaths: ['list', '2', 'size'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: 0,
+            });
+        });
+        test('`options.watch` should work with field path of array length', () => {
+            const onEntityLengthChange = jest.fn();
+            const onListLengthChange = jest.fn();
+            const lengthUseCase = () => {
+                return entityUseCase();
+            };
+            const { result } = renderHook(() => {
+                return useUseCase([], lengthUseCase, {
+                    watch: {
+                        length: onEntityLengthChange,
+                        'list.length': onListLengthChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setEntity }] = cores;
+            expect(onEntityLengthChange).toHaveBeenCalledTimes(0);
+            expect(onListLengthChange).toHaveBeenCalledTimes(0);
+            act(() => {
+                setEntity([{ list: [defaultFile, defaultFile] }]);
+            });
+            expect(onEntityLengthChange).toHaveBeenCalledTimes(1);
+            expect(onListLengthChange).toHaveBeenCalledTimes(1);
+            expect(onEntityLengthChange).toHaveBeenCalledWith({
+                fieldPaths: ['length'],
+                newEntity: [{ list: [defaultFile, defaultFile] }],
+                oldEntity: [],
+                newValue: 1,
+                oldValue: 0,
+            });
+            expect(onListLengthChange).toHaveBeenCalledWith({
+                fieldPaths: ['0', 'list', 'length'],
+                newEntity: [{ list: [defaultFile, defaultFile] }],
+                oldEntity: [],
+                newValue: 2,
+                oldValue: void 0,
+            });
+        });
+        test('`options.watch` should work with field path of nested array', () => {
+            const onChange = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase({}, fieldPathUseCase, {
+                    watch: {
+                        'nestedList.size': onChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setEntity }] = cores;
+            expect(onChange).toHaveBeenCalledTimes(0);
+            act(() => {
+                setEntity({ nestedList: [[[defaultFile]]] });
+            });
+            expect(onChange).toHaveBeenCalledTimes(1);
+            expect(onChange).toHaveBeenCalledWith({
+                fieldPaths: ['nestedList', '0', '0', '0', 'size'],
+                newEntity: { nestedList: [[[defaultFile]]] },
+                oldEntity: {},
+                newValue: 0,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity({
+                    nestedList: [
+                        [
+                            [
+                                { ...defaultFile, size: 100 },
+                                { ...defaultFile, size: 200 },
+                            ],
+                        ],
+                        [[{ ...defaultFile, size: 300 }]],
+                    ],
+                });
+            });
+            expect(onChange).toHaveBeenCalledTimes(4);
+            expect(onChange).toHaveBeenNthCalledWith(2, {
+                fieldPaths: ['nestedList', '0', '0', '0', 'size'],
+                newEntity: {
+                    nestedList: [
+                        [
+                            [
+                                { ...defaultFile, size: 100 },
+                                { ...defaultFile, size: 200 },
+                            ],
+                        ],
+                        [[{ ...defaultFile, size: 300 }]],
+                    ],
+                },
+                oldEntity: { nestedList: [[[defaultFile]]] },
+                newValue: 100,
+                oldValue: 0,
+            });
+            expect(onChange).toHaveBeenNthCalledWith(3, {
+                fieldPaths: ['nestedList', '0', '0', '1', 'size'],
+                newEntity: {
+                    nestedList: [
+                        [
+                            [
+                                { ...defaultFile, size: 100 },
+                                { ...defaultFile, size: 200 },
+                            ],
+                        ],
+                        [[{ ...defaultFile, size: 300 }]],
+                    ],
+                },
+                oldEntity: { nestedList: [[[defaultFile]]] },
+                newValue: 200,
+                oldValue: void 0,
+            });
+            expect(onChange).toHaveBeenNthCalledWith(4, {
+                fieldPaths: ['nestedList', '1', '0', '0', 'size'],
+                newEntity: {
+                    nestedList: [
+                        [
+                            [
+                                { ...defaultFile, size: 100 },
+                                { ...defaultFile, size: 200 },
+                            ],
+                        ],
+                        [[{ ...defaultFile, size: 300 }]],
+                    ],
+                },
+                oldEntity: { nestedList: [[[defaultFile]]] },
+                newValue: 300,
+                oldValue: void 0,
+            });
+        });
+        test('`options.watch` should work with field path of object', () => {
+            const onExtChange = jest.fn();
+            const onSizeChange = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase({}, fieldPathUseCase, {
+                    watch: {
+                        'obj.file.ext': onExtChange,
+                        'obj.file.size': onSizeChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setEntity }] = cores;
+            expect(onExtChange).toHaveBeenCalledTimes(0);
+            act(() => {
+                setEntity({
+                    obj: {
+                        file: {
+                            ext: EXT_1,
+                        },
+                    },
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(1);
+            expect(onSizeChange).toHaveBeenCalledTimes(0);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['obj', 'file', 'ext'],
+                newEntity: {
+                    obj: {
+                        file: {
+                            ext: EXT_1,
+                        },
+                    },
+                },
+                oldEntity: {},
+                newValue: EXT_1,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity(() => {
+                    return {};
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(2);
+            expect(onSizeChange).toHaveBeenCalledTimes(0);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['obj', 'file', 'ext'],
+                newEntity: {},
+                oldEntity: {
+                    obj: {
+                        file: {
+                            ext: EXT_1,
+                        },
+                    },
+                },
+                newValue: void 0,
+                oldValue: EXT_1,
+            });
+        });
         test('multiple `Provider` should work', () => {
             const onNumberMount = jest.fn();
             const onStringMount = jest.fn();
@@ -879,6 +1351,130 @@ describe('useUseCase', () => {
             expect(onSecondChange).toHaveBeenCalledTimes(1);
             expect(onSecondChange).toHaveBeenLastCalledWith(defaultFile, { ...defaultFile, ext: EXT_1, path: PATH_1 });
         });
+        test('`options.watch` should be trigger at child elements', () => {
+            const onExtChange = jest.fn();
+            const firstButtonText = 'first button';
+            const A = () => {
+                const [, { setPath }] = useUseCase(fileUseCase, {
+                    watch: {
+                        ext: onExtChange,
+                    },
+                });
+                const onFirstClick = () => {
+                    setPath(PATH_1);
+                };
+                return _jsx("button", { onClick: onFirstClick, children: firstButtonText });
+            };
+            const B = () => {
+                const [, , Provider] = useUseCase(defaultFile, fileUseCase, {});
+                return (_jsx(Provider, { children: _jsx(A, {}) }));
+            };
+            render(_jsx(B, {}));
+            expect(onExtChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(firstButtonText));
+            expect(onExtChange).toHaveBeenCalledTimes(1);
+            expect(onExtChange).toHaveBeenLastCalledWith({
+                fieldPaths: ['ext'],
+                newEntity: { ...defaultFile, ext: EXT_1, path: PATH_1 },
+                oldEntity: defaultFile,
+                newValue: EXT_1,
+                oldValue: '',
+            });
+        });
+        test('`options.watch` should be trigger in orders', () => {
+            let changeTimes = 0;
+            const updateChangeTimes = (e) => {
+                void e;
+                return ++changeTimes;
+            };
+            const onChangeA = jest.fn(updateChangeTimes);
+            const onChangeB = jest.fn(updateChangeTimes);
+            const onChangeC = jest.fn(updateChangeTimes);
+            const buttonText = 'my button';
+            const A = ({ children }) => {
+                useUseCase(fileUseCase, {
+                    watch: {
+                        ext: onChangeA,
+                    },
+                });
+                return _jsx(Fragment, { children: children });
+            };
+            const B = () => {
+                useUseCase(fileUseCase, {
+                    watch: {
+                        ext: onChangeB,
+                    },
+                });
+                return _jsx(Fragment, {});
+            };
+            const C = () => {
+                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
+                    watch: {
+                        ext: onChangeC,
+                    },
+                });
+                const onFirstClick = () => {
+                    setPath(PATH_1);
+                };
+                return (_jsxs(Provider, { children: [_jsx(A, { children: _jsx(B, {}) }), _jsx("button", { onClick: onFirstClick, children: buttonText })] }));
+            };
+            render(_jsx(C, {}));
+            expect(changeTimes).toBe(0);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(onChangeA).toHaveReturnedWith(2);
+            expect(onChangeB).toHaveReturnedWith(1);
+            expect(onChangeC).toHaveReturnedWith(3);
+        });
+        test.each([UseCaseModes.Normal, UseCaseModes.Stateless])('[mode=%s]: `options.watch` should trigger the latest one in child components', (mode) => {
+            const onFirstExtChange = jest.fn();
+            const onSecondExtChange = jest.fn();
+            let onExtChange = onFirstExtChange;
+            const firstButtonText = 'first button';
+            const secondButtonText = 'second button';
+            const A = () => {
+                const [, { setPath }] = useUseCase(fileUseCase, {
+                    watch: {
+                        ext: onExtChange,
+                    },
+                });
+                const onFirstClick = () => {
+                    setPath(PATH_1);
+                    onExtChange = onSecondExtChange;
+                };
+                const onSecondClick = () => {
+                    setPath('');
+                };
+                return (_jsxs(Fragment, { children: [_jsx("button", { onClick: onFirstClick, children: firstButtonText }), _jsx("button", { onClick: onSecondClick, children: secondButtonText })] }));
+            };
+            const B = () => {
+                const [file, setFile] = useState(defaultFile);
+                const [, , Provider] = useUseCase(file, fileUseCase, mode, {
+                    onChange(newFile) {
+                        if ((mode & UseCaseModes.Stateless) !== UseCaseModes.Stateless) {
+                            return;
+                        }
+                        // `stateless` 不会保存状态，所以需要手动保存
+                        setFile(newFile);
+                    },
+                });
+                return (_jsx(Provider, { children: _jsx(A, {}) }));
+            };
+            render(_jsx(B, {}));
+            expect(onFirstExtChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(firstButtonText));
+            expect(onFirstExtChange).toHaveBeenCalledTimes(1);
+            expect(onSecondExtChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(secondButtonText));
+            expect(onFirstExtChange).toHaveBeenCalledTimes(1);
+            expect(onSecondExtChange).toHaveBeenCalledTimes(1);
+            expect(onSecondExtChange).toHaveBeenLastCalledWith({
+                fieldPaths: ['ext'],
+                newEntity: defaultFile,
+                oldEntity: { ...defaultFile, ext: EXT_1, path: PATH_1 },
+                newValue: '',
+                oldValue: EXT_1,
+            });
+        });
     });
     describe('`useUseCase` should work the same as `useReducers`', () => {
         test('`entity` should equal `defaultFile`', () => {

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

@@ -19,12 +19,26 @@ export type CoreCollection<T, TEntityReducers extends EntityReducers<T>> = RootC
 export interface EntityGetter<T> {
     (): T;
 }
+export interface EntityWatchEvent<T, TValue = unknown> {
+    fieldPaths: string[];
+    newEntity: T;
+    newValue: TValue;
+    oldEntity: T;
+    oldValue: TValue;
+}
+export interface EntityWatcher<T, TValue = unknown> {
+    (event: EntityWatchEvent<T, TValue>): void;
+}
 export type PropertyPath<T, K extends keyof T = keyof T & string> = K extends infer TKey ? `${TKey & (string | number)}${'' | DotAccessorFieldPath<T[TKey & keyof T]>}` : never;
 export type DotAccessorFieldPath<T> = T extends unknown[] ? '.length' | `${'' | `.${number}`}${DotAccessorFieldPath<T[number]>}` : T extends object ? `.${PropertyPath<T>}` : '';
 export type FieldPath<T> = T extends unknown[] ? FieldPath<T[number]> | 'length' : T extends object ? PropertyPath<T> : never;
 export type ExtractPropertyType<T, TPath> = TPath extends `${infer TKey}.${infer TSubPath}` ? T extends unknown[] ? ExtractPropertyType<T[number], TKey extends `${number}` ? TSubPath : TPath> : ExtractPropertyType<T[TKey & keyof T], TSubPath> : T extends unknown[] ? TPath extends 'length' ? T[TPath] : TPath extends `${number}` ? T[number] : ExtractPropertyType<T[number], TPath> : T[TPath & keyof T];
 export type ExtractFieldType<T, TPath> = TPath extends `${infer TKey}.${infer TSubProperty}` ? ExtractPropertyType<T[TKey & keyof T], TSubProperty> : T[TPath & keyof T];
+export type EntityWatchMap<T> = {
+    [K in FieldPath<T>]?: EntityWatcher<T, ExtractFieldType<T, K>>;
+};
 export interface UseCaseHookContextualOptions<T> {
+    watch?: EntityWatchMap<T>;
     onChange?(newEntity: T, oldEntity: T): void;
 }
 export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extends UseCaseHookContextualOptions<T> {

package/es/index.d.ts

@@ -1,7 +1,7 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
 export { useStatelessUseCase } from './hooks/useStatelessUseCase';
-export type { RootCoreCollection, ContextualCoreCollection, CoreCollection } from './hooks/useUseCase/types';
+export type { EntityWatchEvent, RootCoreCollection, ContextualCoreCollection, CoreCollection, } from './hooks/useUseCase/types';
 export type { UseCaseHookOptions } from './hooks/useUseCase/types';
 export type { UseCaseProvider } from './hooks/useProvider/types';
 export type { UseCaseFragmentProps } from './components/UseCaseFragment/types';

package/es/methods/initEntityReducers/index.js

@@ -1,6 +1,6 @@
 import { createEntityReducers } from '@mic-rexjs/usecases';
 export const initEntityReducers = (usecase, store, options) => {
-    const { onChange, options: usecaseOptions, ...restUseCaseOptions } = options;
+    const { watch, onChange, options: usecaseOptions, ...restUseCaseOptions } = options;
     return createEntityReducers(store, usecase, {
         ...restUseCaseOptions,
         ...usecaseOptions,

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

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

package/es/methods/triggerWatchers/index.js

@@ -0,0 +1,14 @@
+import { compareProperty } from '../compareProperty';
+export const triggerWatchers = (watch, newEntity, oldEntity) => {
+    for (const [fieldPath, watcher] of Object.entries(watch)) {
+        compareProperty(oldEntity, newEntity, fieldPath, (oldValue, newValue, fieldPaths) => {
+            watcher({
+                fieldPaths,
+                newEntity,
+                oldEntity,
+                newValue,
+                oldValue,
+            });
+        });
+    }
+};