@mic-rexjs/usecases-react 2.3.0 → 2.3.2

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

@@ -428,6 +428,58 @@ describe('useUseCase', () => {
             expect(onChange).toHaveBeenCalledTimes(1);
             expect(onChange).toHaveBeenLastCalledWith({ ...defaultFile, path: PATH_1, ext: EXT_1 }, defaultFile);
         });
+        test('`options.onChange` should be updated after `deps` changed', () => {
+            const onChange1 = jest.fn();
+            const onChange2 = jest.fn();
+            let onChange = onChange1;
+            let deps = [1];
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, { onChange }, deps);
+            });
+            const { current: cores } = result;
+            const [, reducers] = cores;
+            const { setPath } = reducers;
+            expect(onChange1).toHaveBeenCalledTimes(0);
+            act(() => {
+                setPath(PATH_1);
+                deps = [2];
+                onChange = onChange2;
+            });
+            expect(onChange2).toHaveBeenCalledTimes(0);
+            expect(onChange1).toHaveBeenCalledTimes(1);
+            expect(onChange1).toHaveBeenLastCalledWith({ ...defaultFile, path: PATH_1, ext: EXT_1 }, defaultFile);
+            act(() => {
+                setPath(PATH_2);
+            });
+            expect(onChange1).toHaveBeenCalledTimes(1);
+            expect(onChange2).toHaveBeenCalledTimes(1);
+            expect(onChange2).toHaveBeenLastCalledWith({ ...defaultFile, path: PATH_2, ext: EXT_2 }, { ...defaultFile, path: PATH_1, ext: EXT_1 });
+        });
+        test('`options.onChange` should not be updated if `deps` has not changed', () => {
+            const onChange1 = jest.fn();
+            const onChange2 = jest.fn();
+            let onChange = onChange1;
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, { onChange }, []);
+            });
+            const { current: cores } = result;
+            const [, reducers] = cores;
+            const { setPath } = reducers;
+            expect(onChange1).toHaveBeenCalledTimes(0);
+            act(() => {
+                setPath(PATH_1);
+                onChange = onChange2;
+            });
+            expect(onChange2).toHaveBeenCalledTimes(0);
+            expect(onChange1).toHaveBeenCalledTimes(1);
+            expect(onChange1).toHaveBeenLastCalledWith({ ...defaultFile, path: PATH_1, ext: EXT_1 }, defaultFile);
+            act(() => {
+                setPath(PATH_2);
+            });
+            expect(onChange2).toHaveBeenCalledTimes(0);
+            expect(onChange1).toHaveBeenCalledTimes(2);
+            expect(onChange1).toHaveBeenLastCalledWith({ ...defaultFile, path: PATH_2, ext: EXT_2 }, { ...defaultFile, path: PATH_1, ext: EXT_1 });
+        });
         test('`options.options` should override rest options', () => {
             const { result } = renderHook(() => {
                 return useUseCase(defaultFile, fileUseCase, {
@@ -493,45 +545,6 @@ describe('useUseCase', () => {
                 oldValue: '',
             });
         });
-        test('watcher should be updated after `entity` change', () => {
-            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;
-            onPathChange = onPathChange2;
-            expect(onPathChange1).toHaveBeenCalledTimes(0);
-            act(() => {
-                setPath(PATH_1);
-                setEntity({ size: 5000 });
-            });
-            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(onPathChange2).toHaveBeenCalledTimes(1);
-            expect(onPathChange2).toHaveBeenLastCalledWith({
-                fieldPaths: ['path'],
-                newEntity: { ...defaultFile, size: 5000 },
-                oldEntity: { ...defaultFile, path: PATH_1, size: 5000, ext: EXT_1 },
-                newValue: '',
-                oldValue: PATH_1,
-            });
-        });
         test('when `deps` has changed, it should trigger update', () => {
             const onUpdate = jest.fn();
             const onDeepUpdate = jest.fn();
@@ -576,104 +589,87 @@ describe('useUseCase', () => {
             expect(onUpdate).toHaveBeenCalledTimes(0);
             expect(onDeepUpdate).toHaveBeenCalledTimes(0);
         });
-        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, {
+        test('`options.watch` should be updated after `deps` changed', () => {
+            const onPathChange1 = jest.fn();
+            const onPathChange2 = jest.fn();
+            let onPathChange = onPathChange1;
+            let deps = [1];
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, {
                     watch: {
-                        ext: onParentExtChange,
+                        path: onPathChange,
                     },
-                });
-                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({
-                fieldPaths: ['ext'],
-                newEntity: { ...defaultFile, ext: EXT_1, path: PATH_1 },
+                }, deps);
+            });
+            const { current: cores } = result;
+            const [, { setPath, setEntity }] = cores;
+            expect(onPathChange1).toHaveBeenCalledTimes(0);
+            act(() => {
+                setPath(PATH_1);
+                setEntity({ size: 5000 });
+                deps = [2];
+                onPathChange = onPathChange2;
+            });
+            expect(onPathChange1).toHaveBeenCalledTimes(1);
+            expect(onPathChange1).toHaveBeenLastCalledWith({
+                fieldPaths: ['path'],
+                newEntity: { ...defaultFile, path: PATH_1, ext: EXT_1 },
                 oldEntity: defaultFile,
-                newValue: EXT_1,
+                newValue: PATH_1,
                 oldValue: '',
             });
-            expect(onParentExtChange).toHaveBeenCalledTimes(1);
-            expect(onSecondExtChange).toHaveBeenCalledTimes(0);
-            fireEvent.click(screen.getByText(secondButtonText));
-            expect(onSecondExtChange).toHaveBeenCalledTimes(1);
-            expect(onSecondExtChange).toHaveBeenLastCalledWith({
-                fieldPaths: ['ext'],
-                newEntity: defaultFile,
-                oldEntity: { ...defaultFile, ext: EXT_1, path: PATH_1 },
+            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: EXT_1,
+                oldValue: PATH_1,
             });
-            expect(onFirstExtChange).toHaveBeenCalledTimes(1);
-            expect(onParentExtChange).toHaveBeenCalledTimes(2);
         });
-        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, {
+        test('`options.watch` should not be updated if `deps` has not changed', () => {
+            const onPathChange1 = jest.fn();
+            const onPathChange2 = jest.fn();
+            let onPathChange = onPathChange1;
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, {
                     watch: {
-                        ext: onChangeC,
+                        path: onPathChange,
                     },
-                });
-                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);
+                }, []);
+            });
+            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(onPathChange2).toHaveBeenCalledTimes(0);
+            expect(onPathChange1).toHaveBeenCalledTimes(2);
+            expect(onPathChange1).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();
@@ -1114,7 +1110,7 @@ describe('useUseCase', () => {
         });
     });
     describe('`useUseCase` should work the same as `ModeCoreCollectionHook`', () => {
-        test.each([UseCaseModes.Normal, UseCaseModes.Stateless])('check context type', (mode) => {
+        test.each([UseCaseModes.Normal, UseCaseModes.Stateless])('[mode=%s]: check context type', (mode) => {
             const { result } = renderHook(() => {
                 return useUseCase(defaultFile, fileUseCase, mode);
             });
@@ -1323,24 +1319,36 @@ describe('useUseCase', () => {
             fireEvent.click(screen.getByText(updateButtonText));
             expect(addReducer).toHaveBeenCalledTimes(3);
         });
-        test('`options.onChange` event should be trigger at child elements', () => {
-            const onFirstChange = jest.fn();
-            const onSecondChange = jest.fn();
-            const onParentPathChange = jest.fn();
+        test.each([UseCaseModes.Normal, UseCaseModes.Stateless])('[mode=%s]: `options.watch` should be updated in child element after `deps` changed', (mode) => {
+            const onFirstExtChange = jest.fn();
+            const onSecondExtChange = jest.fn();
+            let onExtChange = onFirstExtChange;
+            let deps = [1];
             const firstButtonText = 'first button';
             const secondButtonText = 'second button';
-            let onChange = onFirstChange;
             const A = () => {
-                useUseCase(fileUseCase, { onChange });
+                useUseCase(fileUseCase, {
+                    watch: {
+                        ext: onExtChange,
+                    },
+                }, deps);
                 return _jsx(Fragment, {});
             };
             const B = () => {
-                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
-                    onChange: onParentPathChange,
+                const [file, setFile] = useState(defaultFile);
+                const [, { setPath }, Provider] = useUseCase(file, fileUseCase, mode, {
+                    onChange(newFile) {
+                        if ((mode & UseCaseModes.Stateless) !== UseCaseModes.Stateless) {
+                            return;
+                        }
+                        // `stateless` 不会保存状态，所以需要手动保存
+                        setFile(newFile);
+                    },
                 });
                 const onFirstClick = () => {
                     setPath(PATH_1);
-                    onChange = onSecondChange;
+                    deps = [2];
+                    onExtChange = onSecondExtChange;
                 };
                 const onSecondClick = () => {
                     setPath('');
@@ -1348,21 +1356,61 @@ describe('useUseCase', () => {
                 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);
+            expect(onFirstExtChange).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);
+            expect(onFirstExtChange).toHaveBeenCalledTimes(1);
+            expect(onSecondExtChange).toHaveBeenCalledTimes(0);
             fireEvent.click(screen.getByText(secondButtonText));
-            expect(onSecondChange).toHaveBeenCalledTimes(1);
-            expect(onSecondChange).toHaveBeenLastCalledWith(defaultFile, {
-                ...defaultFile,
-                ext: EXT_1,
-                path: PATH_1,
+            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,
+            });
+        });
+        test.each([UseCaseModes.Normal, UseCaseModes.Stateless])('`options.watch` should not be updated in child element if `deps` has not changed', (mode) => {
+            const onFirstExtChange = jest.fn();
+            const onSecondExtChange = 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, mode);
+                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(onSecondExtChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(secondButtonText));
+            expect(onFirstExtChange).toHaveBeenCalledTimes(2);
+            expect(onSecondExtChange).toHaveBeenCalledTimes(0);
+            expect(onFirstExtChange).toHaveBeenLastCalledWith({
+                fieldPaths: ['ext'],
+                newEntity: defaultFile,
+                oldEntity: { ...defaultFile, ext: EXT_1, path: PATH_1 },
+                newValue: '',
+                oldValue: EXT_1,
             });
-            expect(onFirstChange).toHaveBeenCalledTimes(1);
-            expect(onParentPathChange).toHaveBeenCalledTimes(2);
         });
         test('`options.onChange` event should be trigger in orders', () => {
             let changeTimes = 0;
@@ -1397,6 +1445,80 @@ describe('useUseCase', () => {
             expect(onChangeB).toHaveReturnedWith(1);
             expect(onChangeC).toHaveReturnedWith(3);
         });
+        test('`options.watch` should be trigger at child elements', () => {
+            const onExtChange = jest.fn();
+            const firstButtonText = 'first button';
+            const A = () => {
+                useUseCase(fileUseCase, {
+                    watch: {
+                        ext: onExtChange,
+                    },
+                });
+                return _jsx(Fragment, {});
+            };
+            const B = () => {
+                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {});
+                const onFirstClick = () => {
+                    setPath(PATH_1);
+                };
+                return (_jsxs(Provider, { children: [_jsx(A, {}), _jsx("button", { onClick: onFirstClick, children: firstButtonText })] }));
+            };
+            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);
+        });
     });
     describe('`useUseCase` should work the same as `useReducers`', () => {
         test('`entity` should equal `defaultFile`', () => {

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

@@ -49,7 +49,7 @@ export interface ReducersHook {
     <T extends Reducers, TUseCaseOptions extends object = object>(usecase: UseCase<T & SymbolSetTarget<NonEntitySymbolSet>, TUseCaseOptions>, options?: TUseCaseOptions, deps?: unknown[]): T;
 }
 export interface ContextualCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducers<T>>(usecase: EntityUseCase<T, TEntityReducers> & UseCase<EntityReducers<T>>, options?: UseCaseHookContextualOptions<T>): ContextualCoreCollection<T, TEntityReducers>;
+    <T, TEntityReducers extends EntityReducers<T>>(usecase: EntityUseCase<T, TEntityReducers> & UseCase<EntityReducers<T>>, options?: UseCaseHookContextualOptions<T>, deps?: unknown[]): ContextualCoreCollection<T, TEntityReducers>;
 }
 export interface RootCoreCollectionHook {
     <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(entity: T | EntityGetter<T>, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & UseCase<EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): RootCoreCollection<T, TEntityReducers>;

package/lib/hooks/useContextualItem/index.js

@@ -6,10 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 exports.useContextualItem = void 0;
 var _ahooks = require("ahooks");
 var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
-var _useMemoizedCall = require("../useMemoizedCall");
+var _cacheCall = require("../../methods/cacheCall");
 var useContextualItem = exports.useContextualItem = function useContextualItem(contextItem, statuses, createFactory) {
-  var deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-  var create = (0, _useMemoizedCall.useMemoizedCall)(createFactory, deps);
+  var depsKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var factoryRef = (0, _ahooks.useLatest)(createFactory);
+  var create = (0, _ahooks.useCreation)(function () {
+    void depsKey;
+    return (0, _cacheCall.cacheCall)(factoryRef.current, {
+      onCompare: function onCompare() {
+        return true;
+      }
+    });
+  }, [depsKey, factoryRef]);
   return (0, _ahooks.useCreation)(function () {
     var rootEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.RootEnabled) === _UseCaseStatuses.UseCaseStatuses.RootEnabled;
     if (!rootEnabled && contextItem) {

package/lib/hooks/useEntity/index.js

@@ -13,14 +13,14 @@ var _getRenderingEntity = require("../../methods/getRenderingEntity");
 var _useContextualItem = require("../useContextualItem");
 var _ahooks = require("ahooks");
 var _triggerWatchers = require("../../methods/triggerWatchers");
-var useEntity = exports.useEntity = function useEntity(statuses, rootEntity, contextStore, options) {
+var useEntity = exports.useEntity = function useEntity(statuses, rootEntity, contextStore, options, depsKey) {
   var _useState = (0, _react.useState)(rootEntity),
     _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
     entityState = _useState2[0],
     setEntityState = _useState2[1];
   var contextEntity = contextStore ? contextStore.value : null;
   var renderingEntity = (0, _getRenderingEntity.getRenderingEntity)(statuses, entityState, rootEntity, contextEntity);
-  var optionsRef = (0, _ahooks.useLatest)(options);
+  var entityEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) === _UseCaseStatuses.UseCaseStatuses.EntityEnabled;
   var entityRootEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.EntityRootEnabled) === _UseCaseStatuses.UseCaseStatuses.EntityRootEnabled;
   var store = (0, _useContextualItem.useContextualItem)(contextStore, statuses, function () {
     if (!entityRootEnabled) {
@@ -36,18 +36,10 @@ var useEntity = exports.useEntity = function useEntity(statuses, rootEntity, con
       }
     });
   });
-  if (entityRootEnabled) {
-    // 执行同步操作
-    store.value = renderingEntity;
-  }
-  (0, _react.useEffect)(function () {
-    if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
-      return;
-    }
+  var rewatch = (0, _ahooks.useMemoizedFn)(function () {
+    var onChange = options.onChange,
+      watch = options.watch;
     var onEntityChange = function onEntityChange(newEntity, oldEntity) {
-      var _optionsRef$current = optionsRef.current,
-        onChange = _optionsRef$current.onChange,
-        watch = _optionsRef$current.watch;
       if (watch) {
         (0, _triggerWatchers.triggerWatchers)(watch, newEntity, oldEntity);
       }
@@ -57,7 +49,17 @@ var useEntity = exports.useEntity = function useEntity(statuses, rootEntity, con
     return function () {
       store.unwatch(onEntityChange);
     };
-  }, [statuses, store, optionsRef]);
+  });
+  if (entityRootEnabled) {
+    // 执行同步操作
+    store.value = renderingEntity;
+  }
+  (0, _react.useEffect)(function () {
+    if (!entityEnabled) {
+      return;
+    }
+    return rewatch();
+  }, [entityEnabled, store, depsKey, rewatch]);
   return (0, _ahooks.useCreation)(function () {
     return [renderingEntity, store];
   }, [renderingEntity, store]);

package/lib/hooks/useUseCase/index.js

@@ -20,6 +20,7 @@ var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
 var _useEntity3 = require("../useEntity");
 var _useContextualItem = require("../useContextualItem");
 var _cacheCalls = require("../../methods/cacheCalls");
+var _useCompareDeps = require("../useCompareDeps");
 var useUseCase = exports.useUseCase = function useUseCase() {
   var isRenderingRef = (0, _useIsRenderingRef.useIsRenderingRef)();
   for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -40,13 +41,14 @@ var useUseCase = exports.useUseCase = function useUseCase() {
   var contextValue = (0, _react.useContext)(context);
   var entityContextValue = contextValue;
   var statuses = (0, _useUseCaseStatuses.useUseCaseStatuses)(argumentTypes, mode, contextValue);
+  var depsKey = (0, _useCompareDeps.useCompareDeps)(deps);
   var _ref = contextValue || {},
     _ref$reducers = _ref.reducers,
     contextReducers = _ref$reducers === void 0 ? null : _ref$reducers;
   var _ref2 = entityContextValue || {},
     _ref2$store = _ref2.store,
     contextStore = _ref2$store === void 0 ? null : _ref2$store;
-  var _useEntity = (0, _useEntity3.useEntity)(statuses, unsafeEntity, contextStore, options),
+  var _useEntity = (0, _useEntity3.useEntity)(statuses, unsafeEntity, contextStore, options, depsKey),
     _useEntity2 = (0, _slicedToArray2["default"])(_useEntity, 2),
     entity = _useEntity2[0],
     store = _useEntity2[1];
@@ -56,7 +58,7 @@ var useUseCase = exports.useUseCase = function useUseCase() {
     }
     var hookOptions = options;
     return (0, _initEntityReducers.initEntityReducers)(entityUseCase, store, hookOptions);
-  }, deps);
+  }, depsKey);
   var Provider = (0, _useProvider.useProvider)(statuses, context, store, reducers);
   return (0, _ahooks.useCreation)(function () {
     if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {