@mic-rexjs/usecases-react 2.12.0 → 2.12.2

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

@@ -1,8 +1,9 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useUseCase } from '.';
 import { useDepsKey } from '../useDepsKey';
 import { beforeEach, describe, expect, jest, test } from '@jest/globals';
-import { entityUseCase, objectUseCase, } from '@mic-rexjs/usecases';
+import { entityUseCase, objectUseCase } from '@mic-rexjs/usecases';
 import { fireEvent, screen } from '@testing-library/dom';
 import { act, render, renderHook } from '@testing-library/react';
 import { useDeepCompareEffect, useMemoizedFn, useMount, useUpdate, useUpdateEffect } from 'ahooks';
@@ -15,1833 +16,2477 @@ const PATH_2 = `hello${EXT_2}`;
 const PARENT_BUTTON_TEXT = 'parent button';
 const CHILD_BUTTON_TEXT = 'child button';
 const defaultFile = {
-    path: '',
-    ext: '',
-    size: 0,
+  path: '',
+  ext: '',
+  size: 0
 };
-const fileUseCase = (options = {}) => {
-    const entityReducers = objectUseCase();
-    const { pathPrefix = '', onPathChange } = options;
-    const init = function* (entity, newEntity = defaultFile) {
-        yield () => {
-            return newEntity;
-        };
-    };
-    const setPath = function* (entity, path) {
-        const { path: oldPath } = entity;
-        const newPath = pathPrefix + path;
-        yield {
-            ...entity,
-            path: newPath,
-            ext: path.match(/\.[^.]+$/)?.[0] || '',
-        };
-        onPathChange?.(newPath, oldPath);
+const fileUseCase = function () {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const entityReducers = objectUseCase();
+  const _options$pathPrefix = options.pathPrefix,
+    pathPrefix = _options$pathPrefix === void 0 ? '' : _options$pathPrefix,
+    onPathChange = options.onPathChange;
+  const init = function (entity) {
+    let newEntity = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultFile;
+    return function* () {
+      yield () => {
+        return newEntity;
+      };
+    }();
+  };
+  const setPath = function* (entity, path) {
+    var _path$match;
+    const oldPath = entity.path;
+    const newPath = pathPrefix + path;
+    yield {
+      ...entity,
+      path: newPath,
+      ext: ((_path$match = path.match(/\.[^.]+$/)) === null || _path$match === void 0 ? void 0 : _path$match[0]) || ''
     };
-    const readFile = async function* (entity, path) {
-        const size = 2000;
-        yield* setPath(entity, path);
-        await Promise.resolve(null);
-        yield (oldEntity) => {
-            return {
-                ...oldEntity,
-                size,
-            };
-        };
-        return size;
+    onPathChange === null || onPathChange === void 0 || onPathChange(newPath, oldPath);
+  };
+  const readFile = async function* (entity, path) {
+    const size = 2000;
+    yield* setPath(entity, path);
+    await Promise.resolve(null);
+    yield oldEntity => {
+      return {
+        ...oldEntity,
+        size
+      };
     };
-    const isImage = (entity) => {
-        const { ext } = entity;
-        return [EXT_1, EXT_2].includes(ext);
-    };
-    return { ...entityReducers, init, setPath, readFile, isImage };
+    return size;
+  };
+  const isImage = entity => {
+    const ext = entity.ext;
+    return [EXT_1, EXT_2].includes(ext);
+  };
+  return {
+    ...entityReducers,
+    init,
+    setPath,
+    readFile,
+    isImage
+  };
 };
 const subtractionReducer = jest.fn((value1, value2) => {
-    return value1 - value2;
+  return value1 - value2;
 });
-const mathUseCase = (options = {}) => {
-    const { extraValue = 0 } = options;
-    const add = (value1, value2) => {
-        return value1 + value2 + extraValue;
-    };
-    return { add, subtraction: subtractionReducer };
+const mathUseCase = function () {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const _options$extraValue = options.extraValue,
+    extraValue = _options$extraValue === void 0 ? 0 : _options$extraValue;
+  const add = (value1, value2) => {
+    return value1 + value2 + extraValue;
+  };
+  return {
+    add,
+    subtraction: subtractionReducer
+  };
 };
 const fieldPathUseCase = () => {
-    return objectUseCase();
+  return objectUseCase();
 };
-const Child = ({ textPrefix = '', onUpdate, onPathChange, onUndefinedEntity }) => {
-    const [file, { setPath }] = useUseCase(fileUseCase);
-    const { path, ext } = file || {};
-    const onClick = () => {
-        setPath(PATH_2);
-    };
-    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 Child = _ref => {
+  let _ref$textPrefix = _ref.textPrefix,
+    textPrefix = _ref$textPrefix === void 0 ? '' : _ref$textPrefix,
+    onUpdate = _ref.onUpdate,
+    onPathChange = _ref.onPathChange,
+    onUndefinedEntity = _ref.onUndefinedEntity;
+  const _useUseCase = useUseCase(fileUseCase),
+    _useUseCase2 = _slicedToArray(_useUseCase, 2),
+    file = _useUseCase2[0],
+    setPath = _useUseCase2[1].setPath;
+  const _ref2 = file || {},
+    path = _ref2.path,
+    ext = _ref2.ext;
+  const onClick = () => {
+    setPath(PATH_2);
+  };
+  const undefinedEntity = useMemoizedFn(() => {
+    onUndefinedEntity === null || onUndefinedEntity === void 0 || onUndefinedEntity();
+  });
+  useUpdateEffect(() => {
+    onUpdate === null || onUpdate === void 0 || onUpdate();
+  });
+  useEffect(() => {
+    if (file === void 0) {
+      undefinedEntity();
+    }
+  }, [file, undefinedEntity]);
+  const pathChange = useMemoizedFn(() => {
+    onPathChange === null || onPathChange === void 0 || 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, onUpdate, onSetPath }) => {
-    const [{ path, ext }, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase);
-    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 Parent = _ref3 => {
+  let children = _ref3.children,
+    onUpdate = _ref3.onUpdate,
+    onSetPath = _ref3.onSetPath;
+  const _useUseCase3 = useUseCase(defaultFile, fileUseCase),
+    _useUseCase4 = _slicedToArray(_useUseCase3, 3),
+    _useUseCase4$ = _useUseCase4[0],
+    path = _useUseCase4$.path,
+    ext = _useUseCase4$.ext,
+    setPath = _useUseCase4[1].setPath,
+    Provider = _useUseCase4[2];
+  const onClick = () => {
+    setPath((onSetPath === null || onSetPath === void 0 ? void 0 : onSetPath()) || '');
+  };
+  useUpdateEffect(() => {
+    onUpdate === null || onUpdate === void 0 || 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 MathParent = _ref4 => {
+  let _ref4$extraValue = _ref4.extraValue,
+    extraValue = _ref4$extraValue === void 0 ? 0 : _ref4$extraValue,
+    onUpdate = _ref4.onUpdate;
+  const _useUseCase5 = useUseCase(mathUseCase, {
+      extraValue
+    }, [extraValue]),
+    add = _useUseCase5.add;
+  const onClick = () => {
+    add(1, 2);
+  };
+  useUpdateEffect(() => {
+    onUpdate === null || onUpdate === void 0 || onUpdate();
+  });
+  return _jsx("div", {
+    children: _jsx("button", {
+      onClick: onClick,
+      children: PARENT_BUTTON_TEXT
+    })
+  });
 };
 const useDeepCompareUpdate = (callback, deps) => {
-    const isFirstRef = useRef(true);
-    const memoizedCallback = useMemoizedFn(callback);
-    const depsKey = useDepsKey(deps);
-    useEffect(() => {
-        return () => {
-            isFirstRef.current = false;
-        };
-    });
-    useDeepCompareEffect(() => {
-        if (isFirstRef.current) {
-            return;
-        }
-        memoizedCallback();
-    }, [depsKey, memoizedCallback]);
+  const isFirstRef = useRef(true);
+  const memoizedCallback = useMemoizedFn(callback);
+  const depsKey = useDepsKey(deps);
+  useEffect(() => {
+    return () => {
+      isFirstRef.current = false;
+    };
+  });
+  useDeepCompareEffect(() => {
+    if (isFirstRef.current) {
+      return;
+    }
+    memoizedCallback();
+  }, [depsKey, memoizedCallback]);
 };
 beforeEach(() => {
-    subtractionReducer.mockClear();
+  subtractionReducer.mockClear();
 });
 describe('useUseCase', () => {
-    describe('`useUseCase` should work the same as `useRootCoreCollection`', () => {
-        test('check context type', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase);
-            });
-            const { current: cores } = result;
-            expect(Array.isArray(cores)).toBe(true);
-            expect(cores).toHaveLength(3);
-        });
-        test('`entity` should equal `defaultFile`', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase);
-            });
-            const { current: cores } = result;
-            const [entity] = cores;
-            expect(entity).toEqual(defaultFile);
-        });
-        test('Should return the `EntityStore.value` if root entity has not changed', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase);
-            });
-            const { current: collection } = result;
-            const [, { setPath }] = collection;
-            act(() => {
-                setPath(PATH_1);
-            });
-            expect(result.current[0]).toEqual({ ...defaultFile, path: PATH_1, ext: EXT_1 });
-        });
-        test('Should return the root entity if root entity has changed', () => {
-            let file = defaultFile;
-            const { result, rerender } = renderHook(() => {
-                return useUseCase(file, fileUseCase);
-            });
-            file = { ...defaultFile, path: PATH_2 };
-            rerender();
-            expect(result.current[0]).toEqual({ ...defaultFile, path: PATH_2 });
-            // 渲染多一次，避免第二次渲染的 `entity` 没变化而取错缓存的情况
-            rerender();
-            expect(result.current[0]).toEqual({ ...defaultFile, path: PATH_2 });
-        });
-        test('Should return the root entity if root entity has changed even with entity state changed', () => {
-            let file = defaultFile;
-            const { result } = renderHook(() => {
-                return useUseCase(file, fileUseCase);
-            });
-            const { current: collection } = result;
-            const [, { setPath }] = collection;
-            act(() => {
-                file = { ...defaultFile, path: PATH_2 };
-                setPath(PATH_1);
-            });
-            expect(result.current[0]).toEqual({ ...defaultFile, path: PATH_2 });
-        });
-        test('Should support entity getter', () => {
-            const file = defaultFile;
-            const { result } = renderHook(() => {
-                return useUseCase(() => {
-                    return file;
-                }, fileUseCase);
-            });
-            const { current: [currentFile], } = result;
-            expect(currentFile).toEqual(file);
-        });
-        test('Entity getter should provide the current entity', () => {
-            let updateIndex = 0;
-            const file = defaultFile;
-            const onFile = jest.fn();
-            const { result } = renderHook(() => {
-                return useUseCase((currentFile) => {
-                    onFile(currentFile);
-                    return currentFile ?? file;
-                }, fileUseCase, {}, [updateIndex++]);
-            });
-            const { current: [, { setPath: setPath1 }], } = result;
-            expect(onFile).toHaveBeenCalledTimes(1);
-            expect(onFile).toHaveBeenCalledWith(void 0);
-            act(() => {
-                setPath1(PATH_1);
-            });
-            const { current: [, { setPath: setPath2 }], } = result;
-            expect(onFile).toHaveBeenCalledTimes(2);
-            expect(onFile).toHaveBeenCalledWith({ ...file, ext: EXT_1, path: PATH_1 });
-            act(() => {
-                setPath2(PATH_2);
-            });
-            expect(onFile).toHaveBeenCalledTimes(3);
-            expect(onFile).toHaveBeenCalledWith({ ...file, ext: EXT_2, path: PATH_2 });
-        });
-        test('Entity getter should provide the changed deps', () => {
-            let updateIndex = 0;
-            const file = defaultFile;
-            const symbol = Symbol('changedDep');
-            const onChangedDeps = jest.fn();
-            const { result } = renderHook(() => {
-                return useUseCase((currentFile = file, changedDeps) => {
-                    // 验证参数类型
-                    const [index1, num1, index2, string1, index3, boolean1] = changedDeps;
-                    const a = index1;
-                    const b = num1;
-                    const c = index2;
-                    const d = string1;
-                    const e = index3;
-                    const f = boolean1;
-                    void a;
-                    void b;
-                    void c;
-                    void d;
-                    void e;
-                    void f;
-                    // 先 `fill` 填充，再合并，以 `symbol` 代替虚无项去匹配
-                    onChangedDeps(Object.assign([...changedDeps].fill(symbol), changedDeps));
-                    return currentFile;
-                }, fileUseCase, {}, [updateIndex++, 0, updateIndex++, 'xyz', updateIndex++, false]);
-            });
-            const { current: [, { setPath: setPath }], } = result;
-            expect(onChangedDeps).toHaveBeenCalledTimes(1);
-            expect(onChangedDeps).toHaveBeenCalledWith([symbol, symbol, symbol, symbol, symbol, symbol]);
-            act(() => {
-                setPath(PATH_1);
-            });
-            expect(onChangedDeps).toHaveBeenCalledTimes(2);
-            expect(onChangedDeps).toHaveBeenCalledWith([3, symbol, 4, symbol, 5, symbol]);
-        });
-        test('Entity property getter should always return the same object if nothing changed after component update', () => {
-            let updateTimes = 0;
-            const data = {
-                x: 1,
-                get obj() {
-                    return {};
-                },
-            };
-            const { rerender } = renderHook(() => {
-                const collection = useUseCase(data, objectUseCase);
-                const [{ obj }] = collection;
-                useMemo(() => {
-                    void obj;
-                    updateTimes++;
-                }, [obj]);
-                return collection;
-            });
-            expect(updateTimes).toEqual(1);
-            act(() => {
-                rerender();
-            });
-            expect(updateTimes).toEqual(1);
+  describe('`useUseCase` should work the same as `useRootCoreCollection`', () => {
+    test('check context type', () => {
+      const _renderHook = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase);
+        }),
+        result = _renderHook.result;
+      const cores = result.current;
+      expect(Array.isArray(cores)).toBe(true);
+      expect(cores).toHaveLength(3);
+    });
+    test('`entity` should equal `defaultFile`', () => {
+      const _renderHook2 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase);
+        }),
+        result = _renderHook2.result;
+      const cores = result.current;
+      const _cores = _slicedToArray(cores, 1),
+        entity = _cores[0];
+      expect(entity).toEqual(defaultFile);
+    });
+    test('Should return the `EntityStore.value` if root entity has not changed', () => {
+      const _renderHook3 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase);
+        }),
+        result = _renderHook3.result;
+      const collection = result.current;
+      const _collection = _slicedToArray(collection, 2),
+        setPath = _collection[1].setPath;
+      act(() => {
+        setPath(PATH_1);
+      });
+      expect(result.current[0]).toEqual({
+        ...defaultFile,
+        path: PATH_1,
+        ext: EXT_1
+      });
+    });
+    test('Should return the root entity if root entity has changed', () => {
+      let file = defaultFile;
+      const _renderHook4 = renderHook(() => {
+          return useUseCase(file, fileUseCase);
+        }),
+        result = _renderHook4.result,
+        rerender = _renderHook4.rerender;
+      file = {
+        ...defaultFile,
+        path: PATH_2
+      };
+      rerender();
+      expect(result.current[0]).toEqual({
+        ...defaultFile,
+        path: PATH_2
+      });
+      // 渲染多一次，避免第二次渲染的 `entity` 没变化而取错缓存的情况
+      rerender();
+      expect(result.current[0]).toEqual({
+        ...defaultFile,
+        path: PATH_2
+      });
+    });
+    test('Should return the root entity if root entity has changed even with entity state changed', () => {
+      let file = defaultFile;
+      const _renderHook5 = renderHook(() => {
+          return useUseCase(file, fileUseCase);
+        }),
+        result = _renderHook5.result;
+      const collection = result.current;
+      const _collection2 = _slicedToArray(collection, 2),
+        setPath = _collection2[1].setPath;
+      act(() => {
+        file = {
+          ...defaultFile,
+          path: PATH_2
+        };
+        setPath(PATH_1);
+      });
+      expect(result.current[0]).toEqual({
+        ...defaultFile,
+        path: PATH_2
+      });
+    });
+    test('Should support entity getter', () => {
+      const file = defaultFile;
+      const _renderHook6 = renderHook(() => {
+          return useUseCase(() => {
+            return file;
+          }, fileUseCase);
+        }),
+        result = _renderHook6.result;
+      const _result$current = _slicedToArray(result.current, 1),
+        currentFile = _result$current[0];
+      expect(currentFile).toEqual(file);
+    });
+    test('Entity getter should provide the current entity', () => {
+      let updateIndex = 0;
+      const file = defaultFile;
+      const onFile = jest.fn();
+      const _renderHook7 = renderHook(() => {
+          return useUseCase(currentFile => {
+            onFile(currentFile);
+            return currentFile !== null && currentFile !== void 0 ? currentFile : file;
+          }, fileUseCase, {}, [updateIndex++]);
+        }),
+        result = _renderHook7.result;
+      const _result$current2 = _slicedToArray(result.current, 2),
+        setPath1 = _result$current2[1].setPath;
+      expect(onFile).toHaveBeenCalledTimes(1);
+      expect(onFile).toHaveBeenCalledWith(void 0);
+      act(() => {
+        setPath1(PATH_1);
+      });
+      const _result$current3 = _slicedToArray(result.current, 2),
+        setPath2 = _result$current3[1].setPath;
+      expect(onFile).toHaveBeenCalledTimes(2);
+      expect(onFile).toHaveBeenCalledWith({
+        ...file,
+        ext: EXT_1,
+        path: PATH_1
+      });
+      act(() => {
+        setPath2(PATH_2);
+      });
+      expect(onFile).toHaveBeenCalledTimes(3);
+      expect(onFile).toHaveBeenCalledWith({
+        ...file,
+        ext: EXT_2,
+        path: PATH_2
+      });
+    });
+    test('Entity getter should provide the changed deps', () => {
+      let updateIndex = 0;
+      const file = defaultFile;
+      const symbol = Symbol('changedDep');
+      const onChangedDeps = jest.fn();
+      const _renderHook8 = renderHook(() => {
+          return useUseCase(function () {
+            let currentFile = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : file;
+            let changedDeps = arguments.length > 1 ? arguments[1] : undefined;
+            // 验证参数类型
+            const _changedDeps = _slicedToArray(changedDeps, 6),
+              index1 = _changedDeps[0],
+              num1 = _changedDeps[1],
+              index2 = _changedDeps[2],
+              string1 = _changedDeps[3],
+              index3 = _changedDeps[4],
+              boolean1 = _changedDeps[5];
+            const a = index1;
+            const b = num1;
+            const c = index2;
+            const d = string1;
+            const e = index3;
+            const f = boolean1;
+            void a;
+            void b;
+            void c;
+            void d;
+            void e;
+            void f;
+            // 先 `fill` 填充，再合并，以 `symbol` 代替虚无项去匹配
+            onChangedDeps(Object.assign([...changedDeps].fill(symbol), changedDeps));
+            return currentFile;
+          }, fileUseCase, {}, [updateIndex++, 0, updateIndex++, 'xyz', updateIndex++, false]);
+        }),
+        result = _renderHook8.result;
+      const _result$current4 = _slicedToArray(result.current, 2),
+        setPath = _result$current4[1].setPath;
+      expect(onChangedDeps).toHaveBeenCalledTimes(1);
+      expect(onChangedDeps).toHaveBeenCalledWith([symbol, symbol, symbol, symbol, symbol, symbol]);
+      act(() => {
+        setPath(PATH_1);
+      });
+      expect(onChangedDeps).toHaveBeenCalledTimes(2);
+      expect(onChangedDeps).toHaveBeenCalledWith([3, symbol, 4, symbol, 5, symbol]);
+    });
+    test('Entity property getter should always return the same object if nothing changed after component update', () => {
+      let updateTimes = 0;
+      const data = {
+        x: 1,
+        get obj() {
+          return {};
+        }
+      };
+      const _renderHook9 = renderHook(() => {
+          const collection = useUseCase(data, objectUseCase);
+          const _collection3 = _slicedToArray(collection, 1),
+            obj = _collection3[0].obj;
+          useMemo(() => {
+            void obj;
+            updateTimes++;
+          }, [obj]);
+          return collection;
+        }),
+        rerender = _renderHook9.rerender;
+      expect(updateTimes).toEqual(1);
+      act(() => {
+        rerender();
+      });
+      expect(updateTimes).toEqual(1);
+    });
+    test('Entity property getter should always return a new object if something changed after component update', () => {
+      let updateTimes = 0;
+      const data = {
+        x: 1,
+        get obj() {
+          return {};
+        }
+      };
+      const _renderHook0 = renderHook(() => {
+          const collection = useUseCase(data, objectUseCase);
+          const _collection4 = _slicedToArray(collection, 1),
+            obj = _collection4[0].obj;
+          useMemo(() => {
+            void obj;
+            updateTimes++;
+          }, [obj]);
+          return collection;
+        }),
+        result = _renderHook0.result;
+      const current = result.current;
+      const _current = _slicedToArray(current, 2),
+        setEntity = _current[1].setEntity;
+      expect(updateTimes).toEqual(1);
+      act(() => {
+        setEntity({
+          x: 2
         });
-        test('Entity property getter should always return a new object if something changed after component update', () => {
-            let updateTimes = 0;
-            const data = {
-                x: 1,
-                get obj() {
-                    return {};
-                },
+      });
+      expect(updateTimes).toEqual(2);
+    });
+    test('Entity getter should provide the first argument with current entity when deps has change.', () => {
+      let entityArg;
+      let times = 0;
+      const file = defaultFile;
+      const _renderHook1 = renderHook(() => {
+          return useUseCase(function () {
+            let entity = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : file;
+            const path = entity.path;
+            entityArg = entity;
+            return {
+              ...entity,
+              path: path + '1'
             };
-            const { result } = renderHook(() => {
-                const collection = useUseCase(data, objectUseCase);
-                const [{ obj }] = collection;
-                useMemo(() => {
-                    void obj;
-                    updateTimes++;
-                }, [obj]);
-                return collection;
-            });
-            const { current } = result;
-            const [, { setEntity }] = current;
-            expect(updateTimes).toEqual(1);
-            act(() => {
-                setEntity({ x: 2 });
-            });
-            expect(updateTimes).toEqual(2);
-        });
-        test('Entity getter should provide the first argument with current entity when deps has change.', () => {
-            let entityArg;
-            let times = 0;
-            const file = defaultFile;
-            const { result } = renderHook(() => {
-                return useUseCase((entity = file) => {
-                    const { path } = entity;
-                    entityArg = entity;
-                    return {
-                        ...entity,
-                        path: path + '1',
-                    };
-                }, fileUseCase, {}, [times++]);
-            });
-            const { current: collection1 } = result;
-            const [currentFile1, { setPath }] = collection1;
-            expect(entityArg).toEqual(defaultFile);
-            expect(currentFile1).toEqual({ ...defaultFile, path: '1' });
-            act(() => {
-                setPath('2');
-            });
-            const { current: collection2 } = result;
-            const [currentFile2] = collection2;
-            expect(entityArg).toEqual({ ...defaultFile, path: '2' });
-            expect(currentFile2).toEqual({ ...defaultFile, path: '21' });
+          }, fileUseCase, {}, [times++]);
+        }),
+        result = _renderHook1.result;
+      const collection1 = result.current;
+      const _collection5 = _slicedToArray(collection1, 2),
+        currentFile1 = _collection5[0],
+        setPath = _collection5[1].setPath;
+      expect(entityArg).toEqual(defaultFile);
+      expect(currentFile1).toEqual({
+        ...defaultFile,
+        path: '1'
+      });
+      act(() => {
+        setPath('2');
+      });
+      const collection2 = result.current;
+      const _collection6 = _slicedToArray(collection2, 1),
+        currentFile2 = _collection6[0];
+      expect(entityArg).toEqual({
+        ...defaultFile,
+        path: '2'
+      });
+      expect(currentFile2).toEqual({
+        ...defaultFile,
+        path: '21'
+      });
+    });
+    test('`reducers` should be returned as an object', () => {
+      const _renderHook10 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase);
+        }),
+        result = _renderHook10.result;
+      const cores = result.current;
+      const _cores2 = _slicedToArray(cores, 2),
+        reducers = _cores2[1];
+      expect(typeof reducers).toBe('object');
+    });
+    test('`Provider` should be returned as a function', () => {
+      const _renderHook11 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase);
+        }),
+        result = _renderHook11.result;
+      const cores = result.current;
+      const _cores3 = _slicedToArray(cores, 3),
+        Provider = _cores3[2];
+      expect(typeof Provider).toBe('function');
+    });
+    test('`usecase` should be called only once if deps has not provided', () => {
+      const mockUseCase = jest.fn(fileUseCase);
+      const _renderHook12 = renderHook(() => {
+          return useUseCase(defaultFile, mockUseCase);
+        }),
+        result = _renderHook12.result,
+        rerender = _renderHook12.rerender;
+      const cores = result.current;
+      const _cores4 = _slicedToArray(cores, 2),
+        setEntity = _cores4[1].setEntity;
+      expect(mockUseCase).toHaveBeenCalledTimes(1);
+      act(() => {
+        setEntity({
+          ...defaultFile
         });
-        test('`reducers` should be returned as an object', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase);
-            });
-            const { current: cores } = result;
-            const [, reducers] = cores;
-            expect(typeof reducers).toBe('object');
+      });
+      rerender();
+      expect(mockUseCase).toHaveBeenCalledTimes(1);
+    });
+    test('`usecase` should be called only once if deps has not changed', () => {
+      const mockUseCase = jest.fn(fileUseCase);
+      const _renderHook13 = renderHook(() => {
+          return useUseCase(defaultFile, mockUseCase, {}, [1, 'x']);
+        }),
+        result = _renderHook13.result,
+        rerender = _renderHook13.rerender;
+      const cores = result.current;
+      const _cores5 = _slicedToArray(cores, 2),
+        setEntity = _cores5[1].setEntity;
+      expect(mockUseCase).toHaveBeenCalledTimes(1);
+      act(() => {
+        setEntity({
+          ...defaultFile
         });
-        test('`Provider` should be returned as a function', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase);
-            });
-            const { current: cores } = result;
-            const [, , Provider] = cores;
-            expect(typeof Provider).toBe('function');
+      });
+      rerender();
+      expect(mockUseCase).toHaveBeenCalledTimes(1);
+    });
+    test('`usecase` should be called if deps has changed', () => {
+      let i = 0;
+      const mockUseCase = jest.fn(fileUseCase);
+      const _renderHook14 = renderHook(() => {
+          return useUseCase(defaultFile, mockUseCase, {}, [i++, 'x']);
+        }),
+        result = _renderHook14.result,
+        rerender = _renderHook14.rerender;
+      const cores = result.current;
+      const _cores6 = _slicedToArray(cores, 2),
+        setEntity = _cores6[1].setEntity;
+      expect(mockUseCase).toHaveBeenCalledTimes(1);
+      act(() => {
+        setEntity({
+          ...defaultFile
         });
-        test('`usecase` should be called only once if deps has not provided', () => {
-            const mockUseCase = jest.fn(fileUseCase);
-            const { result, rerender } = renderHook(() => {
-                return useUseCase(defaultFile, mockUseCase);
-            });
-            const { current: cores } = result;
-            const [, { setEntity }] = cores;
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
-            act(() => {
-                setEntity({
-                    ...defaultFile,
-                });
-            });
-            rerender();
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
+      });
+      expect(mockUseCase).toHaveBeenCalledTimes(1);
+      rerender();
+      expect(mockUseCase).toHaveBeenCalledTimes(2);
+    });
+    test('after call non-generator reducer, it should not trigger update', () => {
+      const onUpdate = jest.fn();
+      const onDeepUpdate = jest.fn();
+      const _renderHook15 = renderHook(() => {
+          const context = useUseCase(defaultFile, fileUseCase);
+          const _context = _slicedToArray(context, 2),
+            reducers = _context[1];
+          const isImage = reducers.isImage;
+          const update = useUpdate();
+          useUpdateEffect(() => {
+            onUpdate();
+          }, [context]);
+          useDeepCompareUpdate(() => {
+            onDeepUpdate();
+          }, [context]);
+          return shouldUpdate => {
+            isImage();
+            if (!shouldUpdate) {
+              return;
+            }
+            update();
+          };
+        }),
+        result = _renderHook15.result;
+      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 _renderHook16 = renderHook(() => {
+          useUpdateEffect(() => {
+            onUpdate();
+          });
+          return useUseCase(defaultFile, fileUseCase);
+        }),
+        result = _renderHook16.result;
+      const cores = result.current;
+      const _cores7 = _slicedToArray(cores, 2),
+        entity = _cores7[0],
+        reducers = _cores7[1];
+      const setPath = reducers.setPath,
+        setEntity = reducers.setEntity;
+      act(() => {
+        setPath(PATH_1);
+        setEntity({
+          size: 5000
         });
-        test('`usecase` should be called only once if deps has not changed', () => {
-            const mockUseCase = jest.fn(fileUseCase);
-            const { result, rerender } = renderHook(() => {
-                return useUseCase(defaultFile, mockUseCase, {}, [1, 'x']);
-            });
-            const { current: cores } = result;
-            const [, { setEntity }] = cores;
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
-            act(() => {
-                setEntity({
-                    ...defaultFile,
-                });
-            });
-            rerender();
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
+      });
+      expect(result.current).not.toBe(cores);
+      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 _renderHook17 = renderHook(() => {
+          useUpdateEffect(() => {
+            onUpdate();
+          });
+          return useUseCase(defaultFile, fileUseCase);
+        }),
+        result = _renderHook17.result;
+      const cores = result.current;
+      const _cores8 = _slicedToArray(cores, 2),
+        entity = _cores8[0],
+        reducers = _cores8[1];
+      const readFile = reducers.readFile;
+      const promise = act(() => {
+        return readFile(PATH_1);
+      });
+      expect(result.current).toBe(cores);
+      expect(result.current).toEqual(cores);
+      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 _renderHook18 = renderHook(() => {
+          useUpdateEffect(() => {
+            onUpdate();
+          });
+          return useUseCase(defaultFile, fileUseCase);
+        }),
+        result = _renderHook18.result;
+      const cores = result.current;
+      const _cores9 = _slicedToArray(cores, 2),
+        reducers = _cores9[1];
+      const init = reducers.init;
+      act(() => {
+        init({
+          ...defaultFile,
+          size: 5000
         });
-        test('`usecase` should be called if deps has changed', () => {
-            let i = 0;
-            const mockUseCase = jest.fn(fileUseCase);
-            const { result, rerender } = renderHook(() => {
-                return useUseCase(defaultFile, mockUseCase, {}, [i++, 'x']);
-            });
-            const { current: cores } = result;
-            const [, { setEntity }] = cores;
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
-            act(() => {
-                setEntity({
-                    ...defaultFile,
-                });
-            });
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
-            rerender();
-            expect(mockUseCase).toHaveBeenCalledTimes(2);
+      });
+      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('reducer call should be cached if component is at rendering phase', () => {
+      const buttonText = 'button';
+      const addReducer = jest.fn((entity, substring) => {
+        return entity + substring;
+      });
+      const stringUseCase = () => {
+        const entityReducers = entityUseCase();
+        return {
+          ...entityReducers,
+          add: addReducer
+        };
+      };
+      const CacheTestComponent = () => {
+        const _useUseCase6 = useUseCase('', stringUseCase),
+          _useUseCase7 = _slicedToArray(_useUseCase6, 2),
+          add = _useUseCase7[1].add;
+        const update = useUpdate();
+        const onClick = () => {
+          update();
+        };
+        add('x');
+        return _jsx("button", {
+          onClick: onClick,
+          children: buttonText
         });
-        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);
+      };
+      render(_jsx(CacheTestComponent, {}));
+      expect(addReducer).toHaveBeenCalledTimes(1);
+      expect(addReducer).toHaveBeenCalledWith('', 'x');
+      expect(addReducer).toHaveReturnedWith('x');
+      fireEvent.click(screen.getByText(buttonText));
+      expect(addReducer).toHaveBeenCalledTimes(1);
+    });
+    test('reducer call should not be cached if component is not at rendering phase', () => {
+      const buttonText = 'button';
+      const addReducer = jest.fn((entity, substring) => {
+        return entity + substring;
+      });
+      const stringUseCase = () => {
+        const entityReducers = entityUseCase();
+        return {
+          ...entityReducers,
+          add: addReducer
+        };
+      };
+      const CacheTestComponent = () => {
+        const _useUseCase8 = useUseCase('', stringUseCase),
+          _useUseCase9 = _slicedToArray(_useUseCase8, 2),
+          add = _useUseCase9[1].add;
+        const onClick = () => {
+          add('x');
+        };
+        useMount(() => {
+          add('x');
+          add('x');
         });
-        test('after `yield entity`, it should trigger update', () => {
-            const onUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                useUpdateEffect(() => {
-                    onUpdate();
-                });
-                return useUseCase(defaultFile, fileUseCase);
-            });
-            const { current: cores } = result;
-            const [entity, reducers] = cores;
-            const { setPath, setEntity } = reducers;
-            act(() => {
-                setPath(PATH_1);
-                setEntity({ size: 5000 });
-            });
-            expect(result.current).not.toBe(cores);
-            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);
+        return _jsx("button", {
+          onClick: onClick,
+          children: buttonText
         });
-        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: cores } = result;
-            const [entity, reducers] = cores;
-            const { readFile } = reducers;
-            const promise = act(() => {
-                return readFile(PATH_1);
-            });
-            expect(result.current).toBe(cores);
-            expect(result.current).toEqual(cores);
-            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);
+      };
+      render(_jsx(CacheTestComponent, {}));
+      expect(addReducer).toHaveBeenCalledTimes(2);
+      expect(addReducer).toHaveBeenNthCalledWith(1, '', 'x');
+      expect(addReducer).toHaveBeenNthCalledWith(2, '', 'x');
+      fireEvent.click(screen.getByText(buttonText));
+      expect(addReducer).toHaveBeenCalledTimes(3);
+      expect(addReducer).toHaveBeenNthCalledWith(3, '', 'x');
+    });
+    test('reducer call should not be cached if entity or parameters have changed', () => {
+      let count = 0;
+      let addedText = 'x';
+      const setButtonText = 'button';
+      const updateButtonText = 'update';
+      const addReducer = jest.fn((entity, substring) => {
+        return entity + substring;
+      });
+      const stringUseCase = () => {
+        const entityReducers = entityUseCase();
+        return {
+          ...entityReducers,
+          add: addReducer
+        };
+      };
+      const CacheTestComponent = () => {
+        const _useUseCase0 = useUseCase('', stringUseCase),
+          _useUseCase1 = _slicedToArray(_useUseCase0, 2),
+          _useUseCase1$ = _useUseCase1[1],
+          add = _useUseCase1$.add,
+          setEntity = _useUseCase1$.setEntity;
+        const update = useUpdate();
+        add(addedText);
+        const onSet = () => {
+          setEntity(`${count++}`);
+        };
+        const onUpdate = () => {
+          update();
+        };
+        return _jsxs("div", {
+          children: [_jsx("button", {
+            onClick: onSet,
+            children: setButtonText
+          }), _jsx("button", {
+            onClick: onUpdate,
+            children: updateButtonText
+          })]
         });
-        test('after `yield entity` callbacks, it should trigger update', () => {
-            const onUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                useUpdateEffect(() => {
-                    onUpdate();
-                });
-                return useUseCase(defaultFile, fileUseCase);
-            });
-            const { current: cores } = result;
-            const [, reducers] = cores;
-            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);
+      };
+      render(_jsx(CacheTestComponent, {}));
+      expect(addReducer).toHaveBeenCalledTimes(1);
+      expect(addReducer).toHaveBeenCalledWith('', 'x');
+      fireEvent.click(screen.getByText(setButtonText));
+      expect(addReducer).toHaveBeenCalledTimes(2);
+      expect(addReducer).toHaveBeenCalledWith('0', 'x');
+      expect(addReducer).toHaveReturnedWith('0x');
+      addedText = 'y';
+      fireEvent.click(screen.getByText(updateButtonText));
+      expect(addReducer).toHaveBeenCalledTimes(3);
+      expect(addReducer).toHaveBeenCalledWith('0', 'y');
+      expect(addReducer).toHaveReturnedWith('0y');
+      fireEvent.click(screen.getByText(updateButtonText));
+      expect(addReducer).toHaveBeenCalledTimes(3);
+    });
+    test('`options.onChange` should be trigger when entity has changed', () => {
+      const onChange = jest.fn();
+      const _renderHook19 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase, {
+            onChange
+          });
+        }),
+        result = _renderHook19.result;
+      const cores = result.current;
+      const _cores0 = _slicedToArray(cores, 2),
+        reducers = _cores0[1];
+      const setPath = reducers.setPath;
+      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.onChange` should always trigger the latest one', () => {
+      const onChange1 = jest.fn();
+      const onChange2 = jest.fn();
+      let onChange = onChange1;
+      const _renderHook20 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase, {
+            onChange
+          }, []);
+        }),
+        result = _renderHook20.result;
+      const cores = result.current;
+      const _cores1 = _slicedToArray(cores, 2),
+        reducers = _cores1[1];
+      const setPath = reducers.setPath;
+      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(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.options` should override rest options', () => {
+      const _renderHook21 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase, {
+            pathPrefix: 'xyz/',
+            options: {
+              pathPrefix: '123/'
+            }
+          });
+        }),
+        result = _renderHook21.result;
+      const cores = result.current;
+      const _cores10 = _slicedToArray(cores, 2),
+        path = _cores10[0].path,
+        reducers = _cores10[1];
+      const setPath = reducers.setPath;
+      expect(path).toBe('');
+      act(() => {
+        setPath(PATH_1);
+      });
+      expect(result.current[0].path).toBe('123/' + PATH_1);
+    });
+    test('Option functions: use `T` (not `S`) when `S extends T`', () => {
+      const testObjectUseCase = function () {
+        let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        const objectReducers = objectUseCase();
+        void options;
+        return {
+          ...objectReducers
+        };
+      };
+      renderHook(() => {
+        useUseCase(defaultFile, testObjectUseCase, {
+          onUpdate(data) {
+            void data;
+            return Promise.reject();
+          }
         });
-        test('reducer call should be cached if component is at rendering phase', () => {
-            const buttonText = 'button';
-            const addReducer = jest.fn((entity, substring) => {
-                return entity + substring;
-            });
-            const stringUseCase = () => {
-                const entityReducers = entityUseCase();
-                return {
-                    ...entityReducers,
-                    add: addReducer,
-                };
-            };
-            const CacheTestComponent = () => {
-                const [, { add }] = useUseCase('', stringUseCase);
-                const update = useUpdate();
-                const onClick = () => {
-                    update();
-                };
-                add('x');
-                return _jsx("button", { onClick: onClick, children: buttonText });
-            };
-            render(_jsx(CacheTestComponent, {}));
-            expect(addReducer).toHaveBeenCalledTimes(1);
-            expect(addReducer).toHaveBeenCalledWith('', 'x');
-            expect(addReducer).toHaveReturnedWith('x');
-            fireEvent.click(screen.getByText(buttonText));
-            expect(addReducer).toHaveBeenCalledTimes(1);
+      });
+      // 这个测试仅仅是为了确保类型不会报错，不验证实际逻辑
+      expect(1).toBe(1);
+    });
+    test('when `options` has changed, it should not trigger update', () => {
+      const onUpdate = jest.fn();
+      const onDeepUpdate = jest.fn();
+      const _renderHook22 = renderHook(() => {
+          const _useState = useState('user/'),
+            _useState2 = _slicedToArray(_useState, 2),
+            pathPrefix = _useState2[0],
+            setPathPrefix = _useState2[1];
+          const context = useUseCase(defaultFile, fileUseCase, {
+            pathPrefix
+          });
+          useUpdateEffect(() => {
+            onUpdate();
+          }, [context]);
+          useDeepCompareUpdate(() => {
+            onDeepUpdate();
+          }, [context]);
+          return setPathPrefix;
+        }),
+        result = _renderHook22.result;
+      expect(onUpdate).toHaveBeenCalledTimes(0);
+      expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+      act(() => {
+        result.current('my/');
+      });
+      expect(onUpdate).toHaveBeenCalledTimes(0);
+      expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+    });
+    test('when `deps` has changed, it should trigger update', () => {
+      const onUpdate = jest.fn();
+      const onDeepUpdate = jest.fn();
+      const _renderHook23 = renderHook(() => {
+          const _useState3 = useState('user/'),
+            _useState4 = _slicedToArray(_useState3, 2),
+            pathPrefix = _useState4[0],
+            setPathPrefix = _useState4[1];
+          const context = useUseCase(defaultFile, fileUseCase, {
+            pathPrefix
+          }, [pathPrefix]);
+          useUpdateEffect(() => {
+            onUpdate();
+          }, [context]);
+          useDeepCompareUpdate(() => {
+            onDeepUpdate();
+          }, [context]);
+          return setPathPrefix;
+        }),
+        result = _renderHook23.result;
+      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 _renderHook24 = renderHook(() => {
+          const _useState5 = useState('user/'),
+            _useState6 = _slicedToArray(_useState5, 2),
+            pathPrefix = _useState6[0],
+            setPathPrefix = _useState6[1];
+          const context = useUseCase(defaultFile, fileUseCase, {
+            pathPrefix
+          }, []);
+          useUpdateEffect(() => {
+            onUpdate();
+          }, [context]);
+          useDeepCompareUpdate(() => {
+            onDeepUpdate();
+          }, [context]);
+          return setPathPrefix;
+        }),
+        result = _renderHook24.result;
+      expect(onUpdate).toHaveBeenCalledTimes(0);
+      expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+      act(() => {
+        result.current('my/');
+      });
+      expect(onUpdate).toHaveBeenCalledTimes(0);
+      expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+    });
+    test(`should call latest functions of usecase options even deps has not change`, () => {
+      const onPathChange1 = jest.fn();
+      const onPathChange2 = jest.fn();
+      let onPathChange = onPathChange1;
+      const _renderHook25 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase, {
+            onPathChange
+          });
+        }),
+        result = _renderHook25.result;
+      const context = result.current;
+      const _context2 = _slicedToArray(context, 2),
+        setPath = _context2[1].setPath;
+      act(() => {
+        setPath(PATH_1);
+        onPathChange = onPathChange2;
+      });
+      expect(onPathChange1).toHaveBeenCalledTimes(1);
+      expect(onPathChange2).toHaveBeenCalledTimes(0);
+      expect(onPathChange1).toHaveBeenLastCalledWith(PATH_1, '');
+      act(() => {
+        setPath(PATH_2);
+      });
+      expect(onPathChange1).toHaveBeenCalledTimes(1);
+      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 _renderHook26 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase, {
+            watch: {
+              path: onPathChange,
+              size: onSizeChange
+            }
+          });
+        }),
+        result = _renderHook26.result;
+      const cores = result.current;
+      const _cores11 = _slicedToArray(cores, 2),
+        setPath = _cores11[1].setPath;
+      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 _renderHook27 = renderHook(() => {
+          return useUseCase(defaultFile, fileUseCase, {
+            watch: {
+              path: onPathChange
+            }
+          });
+        }),
+        result = _renderHook27.result;
+      const cores = result.current;
+      const _cores12 = _slicedToArray(cores, 2),
+        _cores12$ = _cores12[1],
+        setPath = _cores12$.setPath,
+        setEntity = _cores12$.setEntity;
+      expect(onPathChange1).toHaveBeenCalledTimes(0);
+      act(() => {
+        setPath(PATH_1);
+        setEntity({
+          size: 5000
         });
-        test('reducer call should not be cached if component is not at rendering phase', () => {
-            const buttonText = 'button';
-            const addReducer = jest.fn((entity, substring) => {
-                return entity + substring;
-            });
-            const stringUseCase = () => {
-                const entityReducers = entityUseCase();
-                return {
-                    ...entityReducers,
-                    add: addReducer,
-                };
-            };
-            const CacheTestComponent = () => {
-                const [, { add }] = useUseCase('', stringUseCase);
-                const onClick = () => {
-                    add('x');
-                };
-                useMount(() => {
-                    add('x');
-                    add('x');
-                });
-                return _jsx("button", { onClick: onClick, children: buttonText });
-            };
-            render(_jsx(CacheTestComponent, {}));
-            expect(addReducer).toHaveBeenCalledTimes(2);
-            expect(addReducer).toHaveBeenNthCalledWith(1, '', 'x');
-            expect(addReducer).toHaveBeenNthCalledWith(2, '', 'x');
-            fireEvent.click(screen.getByText(buttonText));
-            expect(addReducer).toHaveBeenCalledTimes(3);
-            expect(addReducer).toHaveBeenNthCalledWith(3, '', 'x');
+        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 initialData = {};
+      const onExtChange = jest.fn();
+      const onSizeChange = jest.fn();
+      const _renderHook28 = renderHook(() => {
+          return useUseCase(initialData, fieldPathUseCase, {
+            watch: {
+              'list.ext': onExtChange,
+              'list.size': onSizeChange
+            }
+          });
+        }),
+        result = _renderHook28.result;
+      const cores = result.current;
+      const _cores13 = _slicedToArray(cores, 2),
+        setEntity = _cores13[1].setEntity;
+      act(() => {
+        setEntity({
+          list: [defaultFile]
         });
-        test('reducer call should not be cached if entity or parameters have changed', () => {
-            let count = 0;
-            let addedText = 'x';
-            const setButtonText = 'button';
-            const updateButtonText = 'update';
-            const addReducer = jest.fn((entity, substring) => {
-                return entity + substring;
-            });
-            const stringUseCase = () => {
-                const entityReducers = entityUseCase();
-                return {
-                    ...entityReducers,
-                    add: addReducer,
-                };
-            };
-            const CacheTestComponent = () => {
-                const [, { add, setEntity }] = useUseCase('', stringUseCase);
-                const update = useUpdate();
-                add(addedText);
-                const onSet = () => {
-                    setEntity(`${count++}`);
-                };
-                const onUpdate = () => {
-                    update();
-                };
-                return (_jsxs("div", { children: [_jsx("button", { onClick: onSet, children: setButtonText }), _jsx("button", { onClick: onUpdate, children: updateButtonText })] }));
-            };
-            render(_jsx(CacheTestComponent, {}));
-            expect(addReducer).toHaveBeenCalledTimes(1);
-            expect(addReducer).toHaveBeenCalledWith('', 'x');
-            fireEvent.click(screen.getByText(setButtonText));
-            expect(addReducer).toHaveBeenCalledTimes(2);
-            expect(addReducer).toHaveBeenCalledWith('0', 'x');
-            expect(addReducer).toHaveReturnedWith('0x');
-            addedText = 'y';
-            fireEvent.click(screen.getByText(updateButtonText));
-            expect(addReducer).toHaveBeenCalledTimes(3);
-            expect(addReducer).toHaveBeenCalledWith('0', 'y');
-            expect(addReducer).toHaveReturnedWith('0y');
-            fireEvent.click(screen.getByText(updateButtonText));
-            expect(addReducer).toHaveBeenCalledTimes(3);
+      });
+      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
+          }]
         });
-        test('`options.onChange` should be trigger when entity has changed', () => {
-            const onChange = jest.fn();
-            const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase, { onChange });
-            });
-            const { current: cores } = result;
-            const [, reducers] = cores;
-            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);
+      });
+      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
+          }]
         });
-        test('`options.onChange` should always trigger the latest one', () => {
-            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(onChange1).toHaveBeenCalledTimes(1);
-            expect(onChange2).toHaveBeenCalledTimes(1);
-            expect(onChange2).toHaveBeenLastCalledWith({ ...defaultFile, path: PATH_2, ext: EXT_2 }, { ...defaultFile, path: PATH_1, ext: EXT_1 });
+      });
+      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: []
         });
-        test('`options.options` should override rest options', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase, {
-                    pathPrefix: 'xyz/',
-                    options: { pathPrefix: '123/' },
-                });
-            });
-            const { current: cores } = result;
-            const [{ path }, reducers] = cores;
-            const { setPath } = reducers;
-            expect(path).toBe('');
-            act(() => {
-                setPath(PATH_1);
-            });
-            expect(result.current[0].path).toBe('123/' + PATH_1);
+      });
+      expect(onExtChange).toHaveBeenCalledTimes(3);
+      expect(onSizeChange).toHaveBeenCalledTimes(2);
+      act(() => {
+        setEntity(() => {
+          return {
+            list: [{
+              ...defaultFile,
+              ext: EXT_2
+            }, {
+              ...defaultFile,
+              ext: EXT_1
+            }, defaultFile]
+          };
         });
-        test('Option functions: use `T` (not `S`) when `S extends T`', () => {
-            const testObjectUseCase = (options = {}) => {
-                const objectReducers = objectUseCase();
-                void options;
-                return { ...objectReducers };
-            };
-            renderHook(() => {
-                useUseCase(defaultFile, testObjectUseCase, {
-                    onUpdate(data) {
-                        void data;
-                        return Promise.reject();
-                    },
-                });
-            });
-            // 这个测试仅仅是为了确保类型不会报错，不验证实际逻辑
-            expect(1).toBe(1);
+      });
+      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 {};
         });
-        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);
+      });
+      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 _renderHook29 = renderHook(() => {
+          return useUseCase([], lengthUseCase, {
+            watch: {
+              length: onEntityLengthChange,
+              'list.length': onListLengthChange
+            }
+          });
+        }),
+        result = _renderHook29.result;
+      const cores = result.current;
+      const _cores14 = _slicedToArray(cores, 2),
+        setEntity = _cores14[1].setEntity;
+      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 initialData = {};
+      const onChange = jest.fn();
+      const _renderHook30 = renderHook(() => {
+          return useUseCase(initialData, fieldPathUseCase, {
+            watch: {
+              'nestedList.size': onChange
+            }
+          });
+        }),
+        result = _renderHook30.result;
+      const cores = result.current;
+      const _cores15 = _slicedToArray(cores, 2),
+        setEntity = _cores15[1].setEntity;
+      expect(onChange).toHaveBeenCalledTimes(0);
+      act(() => {
+        setEntity({
+          nestedList: [[[defaultFile]]]
         });
-        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);
+      });
+      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
+          }]]]
         });
-        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);
+      });
+      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 initialData = {};
+      const onExtChange = jest.fn();
+      const onSizeChange = jest.fn();
+      const _renderHook31 = renderHook(() => {
+          return useUseCase(initialData, fieldPathUseCase, {
+            watch: {
+              'obj.file.ext': onExtChange,
+              'obj.file.size': onSizeChange
+            }
+          });
+        }),
+        result = _renderHook31.result;
+      const cores = result.current;
+      const _cores16 = _slicedToArray(cores, 2),
+        setEntity = _cores16[1].setEntity;
+      expect(onExtChange).toHaveBeenCalledTimes(0);
+      act(() => {
+        setEntity({
+          obj: {
+            file: {
+              ext: EXT_1
+            }
+          }
         });
-        test(`should call latest functions of usecase options even deps has not change`, () => {
-            const onPathChange1 = jest.fn();
-            const onPathChange2 = jest.fn();
-            let onPathChange = onPathChange1;
-            const { result } = renderHook(() => {
-                return useUseCase(defaultFile, fileUseCase, { onPathChange });
-            });
-            const { current: context } = result;
-            const [, { setPath }] = context;
-            act(() => {
-                setPath(PATH_1);
-                onPathChange = onPathChange2;
-            });
-            expect(onPathChange1).toHaveBeenCalledTimes(1);
-            expect(onPathChange2).toHaveBeenCalledTimes(0);
-            expect(onPathChange1).toHaveBeenLastCalledWith(PATH_1, '');
-            act(() => {
-                setPath(PATH_2);
-            });
-            expect(onPathChange1).toHaveBeenCalledTimes(1);
-            expect(onPathChange2).toHaveBeenCalledTimes(1);
-            expect(onPathChange2).toHaveBeenLastCalledWith(PATH_2, PATH_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 {};
         });
-        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: '',
-            });
+      });
+      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();
+      const onBooleanMount = jest.fn();
+      const numberUseCase = () => {
+        return entityUseCase();
+      };
+      const stringUseCase = () => {
+        return entityUseCase();
+      };
+      const booleanUseCase = () => {
+        return entityUseCase();
+      };
+      const TestChildComponent = () => {
+        const _useUseCase10 = useUseCase(numberUseCase),
+          _useUseCase11 = _slicedToArray(_useUseCase10, 1),
+          numberValue = _useUseCase11[0];
+        const _useUseCase12 = useUseCase(stringUseCase),
+          _useUseCase13 = _slicedToArray(_useUseCase12, 1),
+          stringValue = _useUseCase13[0];
+        const _useUseCase14 = useUseCase(booleanUseCase),
+          _useUseCase15 = _slicedToArray(_useUseCase14, 1),
+          booleanValue = _useUseCase15[0];
+        useMount(() => {
+          onNumberMount(numberValue);
+          onStringMount(stringValue);
+          onBooleanMount(booleanValue);
         });
-        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,
-            });
+        return null;
+      };
+      const TestParentComponent = () => {
+        const _useUseCase16 = useUseCase(11, numberUseCase),
+          _useUseCase17 = _slicedToArray(_useUseCase16, 3),
+          NumberProvider = _useUseCase17[2];
+        const _useUseCase18 = useUseCase('hello', stringUseCase),
+          _useUseCase19 = _slicedToArray(_useUseCase18, 3),
+          StringProvider = _useUseCase19[2];
+        const _useUseCase20 = useUseCase(true, booleanUseCase),
+          _useUseCase21 = _slicedToArray(_useUseCase20, 3),
+          BooleanProvider = _useUseCase21[2];
+        return _jsx(NumberProvider, {
+          with: [StringProvider, BooleanProvider],
+          children: _jsx(TestChildComponent, {})
         });
-        test('`options.watch` should work with array field path of array', () => {
-            const initialData = {};
-            const onExtChange = jest.fn();
-            const onSizeChange = jest.fn();
-            const { result } = renderHook(() => {
-                return useUseCase(initialData, 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,
-            });
+      };
+      render(_jsx(TestParentComponent, {}));
+      expect(onNumberMount).toHaveBeenCalledWith(11);
+      expect(onStringMount).toHaveBeenCalledWith('hello');
+      expect(onBooleanMount).toHaveBeenCalledWith(true);
+    });
+  });
+  describe('`useUseCase` should work the same as `useContextualCoreCollection`', () => {
+    test('Provider should be returned in child component', () => {
+      const onCore = jest.fn();
+      const TestChild = () => {
+        const core = useUseCase(fileUseCase);
+        const length = core.length;
+        const _core = _slicedToArray(core, 3),
+          file = _core[0],
+          Provider = _core[2];
+        useEffect(() => {
+          onCore(file, length, typeof Provider);
         });
-        test('`options.watch` should work with field path of array length', () => {
-            const onEntityLengthChange = jest.fn();
-            const onListLengthChange = jest.fn();
-            const lengthUseCase = () => {
-                return entityUseCase();
+        return _jsx(Fragment, {});
+      };
+      const TestParent = () => {
+        const _useUseCase22 = useUseCase(() => {
+            return {
+              ...defaultFile,
+              ext: EXT_1
             };
-            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 initialData = {};
-            const onChange = jest.fn();
-            const { result } = renderHook(() => {
-                return useUseCase(initialData, 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,
-            });
+          }, fileUseCase),
+          _useUseCase23 = _slicedToArray(_useUseCase22, 3),
+          Provider = _useUseCase23[2];
+        return _jsx(Provider, {
+          children: _jsx(TestChild, {})
         });
-        test('`options.watch` should work with field path of object', () => {
-            const initialData = {};
-            const onExtChange = jest.fn();
-            const onSizeChange = jest.fn();
-            const { result } = renderHook(() => {
-                return useUseCase(initialData, 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,
-            });
+      };
+      render(_jsx(TestParent, {}));
+      expect(onCore).toHaveBeenCalledWith({
+        ...defaultFile,
+        ext: EXT_1
+      }, 3, 'function');
+    });
+    test('Provider should work in child component or popup component', () => {
+      const onChange = jest.fn();
+      const onRootFile = jest.fn();
+      const onPopupFile = jest.fn();
+      const buttonText = 'button';
+      const Popup = () => {
+        const _useUseCase24 = useUseCase(fileUseCase),
+          _useUseCase25 = _slicedToArray(_useUseCase24, 2),
+          file = _useUseCase25[0],
+          setEntity = _useUseCase25[1].setEntity;
+        const onClick = () => {
+          setEntity({
+            ext: EXT_2
+          });
+        };
+        useEffect(() => {
+          onPopupFile(file);
+        }, [file]);
+        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 entityUseCase();
-            };
-            const stringUseCase = () => {
-                return entityUseCase();
-            };
-            const booleanUseCase = () => {
-                return entityUseCase();
-            };
-            const TestChildComponent = () => {
-                const [numberValue] = useUseCase(numberUseCase);
-                const [stringValue] = useUseCase(stringUseCase);
-                const [booleanValue] = useUseCase(booleanUseCase);
-                useMount(() => {
-                    onNumberMount(numberValue);
-                    onStringMount(stringValue);
-                    onBooleanMount(booleanValue);
-                });
-                return null;
-            };
-            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, {}) }));
+      };
+      const TestChild = () => {
+        const _useUseCase26 = useUseCase(fileUseCase),
+          _useUseCase27 = _slicedToArray(_useUseCase26, 3),
+          Provider = _useUseCase27[2];
+        return createPortal(_jsx(Provider, {
+          children: _jsx(Popup, {})
+        }), document.body);
+      };
+      const TestParent = () => {
+        const _useUseCase28 = useUseCase(() => {
+            return {
+              ...defaultFile,
+              ext: EXT_1
             };
-            render(_jsx(TestParentComponent, {}));
-            expect(onNumberMount).toHaveBeenCalledWith(11);
-            expect(onStringMount).toHaveBeenCalledWith('hello');
-            expect(onBooleanMount).toHaveBeenCalledWith(true);
+          }, fileUseCase, {
+            onChange
+          }),
+          _useUseCase29 = _slicedToArray(_useUseCase28, 3),
+          file = _useUseCase29[0],
+          Provider = _useUseCase29[2];
+        useEffect(() => {
+          onRootFile(file);
+        }, [file]);
+        return _jsx(Provider, {
+          children: _jsx(TestChild, {})
         });
+      };
+      render(_jsx(TestParent, {}));
+      expect(onRootFile).toHaveBeenCalledWith({
+        ...defaultFile,
+        ext: EXT_1
+      });
+      expect(onPopupFile).toHaveBeenCalledWith({
+        ...defaultFile,
+        ext: EXT_1
+      });
+      fireEvent.click(screen.getByText(buttonText));
+      expect(onRootFile).toHaveBeenCalledWith({
+        ...defaultFile,
+        ext: EXT_2
+      });
+      expect(onPopupFile).toHaveBeenCalledWith({
+        ...defaultFile,
+        ext: EXT_2
+      });
     });
-    describe('`useUseCase` should work the same as `useContextualCoreCollection`', () => {
-        test('Provider should be returned in child component', () => {
-            const onCore = jest.fn();
-            const TestChild = () => {
-                const core = useUseCase(fileUseCase);
-                const { length } = core;
-                const [file, , Provider] = core;
-                useEffect(() => {
-                    onCore(file, length, typeof Provider);
-                });
-                return _jsx(Fragment, {});
-            };
-            const TestParent = () => {
-                const [, , Provider] = useUseCase(() => {
-                    return { ...defaultFile, ext: EXT_1 };
-                }, fileUseCase);
-                return (_jsx(Provider, { children: _jsx(TestChild, {}) }));
-            };
-            render(_jsx(TestParent, {}));
-            expect(onCore).toHaveBeenCalledWith({ ...defaultFile, ext: EXT_1 }, 3, 'function');
+    test('Should trigger Parent & Child to update', () => {
+      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,
+          onUpdate: onParentUpdate,
+          children: _jsx(Child, {
+            onUpdate: onChildUpdate,
+            onPathChange: onPathChange,
+            onUndefinedEntity: onUndefinedEntity
+          })
+        })
+      }));
+      fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
+      expect(onSetPath).toHaveBeenCalledTimes(1);
+      expect(onParentUpdate).toHaveBeenCalledTimes(1);
+      expect(onChildUpdate).toHaveBeenCalledTimes(1);
+      expect(onPathChange).toHaveBeenCalledWith(PATH_1);
+      fireEvent.click(screen.getByText(CHILD_BUTTON_TEXT));
+      expect(onSetPath).toHaveBeenCalledTimes(1);
+      expect(onParentUpdate).toHaveBeenCalledTimes(2);
+      expect(onChildUpdate).toHaveBeenCalledTimes(2);
+      expect(onPathChange).toHaveBeenCalledWith(PATH_2);
+      expect(onUndefinedEntity).toHaveBeenCalledTimes(0);
+    });
+    test('`usecase` should not be called at child component', () => {
+      const mockUseCase = jest.fn(fileUseCase);
+      const A = () => {
+        useUseCase(mockUseCase);
+        return _jsx(Fragment, {});
+      };
+      const B = () => {
+        const _useUseCase30 = useUseCase(defaultFile, mockUseCase),
+          _useUseCase31 = _slicedToArray(_useUseCase30, 3),
+          Provider = _useUseCase31[2];
+        return _jsx(Provider, {
+          children: _jsx(A, {})
         });
-        test('Provider should work in child component or popup component', () => {
-            const onChange = jest.fn();
-            const onRootFile = jest.fn();
-            const onPopupFile = jest.fn();
-            const buttonText = 'button';
-            const Popup = () => {
-                const [file, { setEntity }] = useUseCase(fileUseCase);
-                const onClick = () => {
-                    setEntity({ ext: EXT_2 });
-                };
-                useEffect(() => {
-                    onPopupFile(file);
-                }, [file]);
-                return _jsx("button", { onClick: onClick, children: buttonText });
-            };
-            const TestChild = () => {
-                const [, , Provider] = useUseCase(fileUseCase);
-                return createPortal(_jsx(Provider, { children: _jsx(Popup, {}) }), document.body);
-            };
-            const TestParent = () => {
-                const [file, , Provider] = useUseCase(() => {
-                    return { ...defaultFile, ext: EXT_1 };
-                }, fileUseCase, { onChange });
-                useEffect(() => {
-                    onRootFile(file);
-                }, [file]);
-                return (_jsx(Provider, { children: _jsx(TestChild, {}) }));
-            };
-            render(_jsx(TestParent, {}));
-            expect(onRootFile).toHaveBeenCalledWith({ ...defaultFile, ext: EXT_1 });
-            expect(onPopupFile).toHaveBeenCalledWith({ ...defaultFile, ext: EXT_1 });
-            fireEvent.click(screen.getByText(buttonText));
-            expect(onRootFile).toHaveBeenCalledWith({ ...defaultFile, ext: EXT_2 });
-            expect(onPopupFile).toHaveBeenCalledWith({ ...defaultFile, ext: EXT_2 });
+      };
+      render(_jsx(B, {}));
+      expect(mockUseCase).toHaveBeenCalledTimes(1);
+    });
+    test('reducer call should be cached if component is at rendering phase in child components', () => {
+      const buttonText = 'button';
+      const addReducer = jest.fn((entity, substring) => {
+        return entity + substring;
+      });
+      const stringUseCase = () => {
+        const entityReducers = entityUseCase();
+        return {
+          ...entityReducers,
+          add: addReducer
+        };
+      };
+      const A = () => {
+        const _useUseCase32 = useUseCase(stringUseCase),
+          _useUseCase33 = _slicedToArray(_useUseCase32, 2),
+          add = _useUseCase33[1].add;
+        const update = useUpdate();
+        const onClick = () => {
+          update();
+        };
+        add('x');
+        return _jsx("button", {
+          onClick: onClick,
+          children: buttonText
         });
-        test('Should trigger Parent & Child to update', () => {
-            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, onUpdate: onParentUpdate, children: _jsx(Child, { onUpdate: onChildUpdate, onPathChange: onPathChange, onUndefinedEntity: onUndefinedEntity }) }) }));
-            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
-            expect(onSetPath).toHaveBeenCalledTimes(1);
-            expect(onParentUpdate).toHaveBeenCalledTimes(1);
-            expect(onChildUpdate).toHaveBeenCalledTimes(1);
-            expect(onPathChange).toHaveBeenCalledWith(PATH_1);
-            fireEvent.click(screen.getByText(CHILD_BUTTON_TEXT));
-            expect(onSetPath).toHaveBeenCalledTimes(1);
-            expect(onParentUpdate).toHaveBeenCalledTimes(2);
-            expect(onChildUpdate).toHaveBeenCalledTimes(2);
-            expect(onPathChange).toHaveBeenCalledWith(PATH_2);
-            expect(onUndefinedEntity).toHaveBeenCalledTimes(0);
+      };
+      const B = () => {
+        const _useUseCase34 = useUseCase('', stringUseCase),
+          _useUseCase35 = _slicedToArray(_useUseCase34, 3),
+          Provider = _useUseCase35[2];
+        return _jsx(Provider, {
+          children: _jsx(A, {})
         });
-        test('`usecase` should not be called at child component', () => {
-            const mockUseCase = jest.fn(fileUseCase);
-            const A = () => {
-                useUseCase(mockUseCase);
-                return _jsx(Fragment, {});
-            };
-            const B = () => {
-                const [, , Provider] = useUseCase(defaultFile, mockUseCase);
-                return (_jsx(Provider, { children: _jsx(A, {}) }));
-            };
-            render(_jsx(B, {}));
-            expect(mockUseCase).toHaveBeenCalledTimes(1);
+      };
+      render(_jsx(B, {}));
+      expect(addReducer).toHaveBeenCalledTimes(1);
+      expect(addReducer).toHaveBeenCalledWith('', 'x');
+      expect(addReducer).toHaveReturnedWith('x');
+      fireEvent.click(screen.getByText(buttonText));
+      expect(addReducer).toHaveBeenCalledTimes(1);
+    });
+    test('reducer call should not be cached if component is not at rendering phase in child components', () => {
+      const buttonText = 'button';
+      const addReducer = jest.fn((entity, substring) => {
+        return entity + substring;
+      });
+      const stringUseCase = () => {
+        const entityReducers = entityUseCase();
+        return {
+          ...entityReducers,
+          add: addReducer
+        };
+      };
+      const A = () => {
+        const _useUseCase36 = useUseCase(stringUseCase),
+          _useUseCase37 = _slicedToArray(_useUseCase36, 2),
+          add = _useUseCase37[1].add;
+        const onClick = () => {
+          add('x');
+        };
+        useMount(() => {
+          add('x');
+          add('x');
         });
-        test('reducer call should be cached if component is at rendering phase in child components', () => {
-            const buttonText = 'button';
-            const addReducer = jest.fn((entity, substring) => {
-                return entity + substring;
-            });
-            const stringUseCase = () => {
-                const entityReducers = entityUseCase();
-                return {
-                    ...entityReducers,
-                    add: addReducer,
-                };
-            };
-            const A = () => {
-                const [, { add }] = useUseCase(stringUseCase);
-                const update = useUpdate();
-                const onClick = () => {
-                    update();
-                };
-                add('x');
-                return _jsx("button", { onClick: onClick, children: buttonText });
-            };
-            const B = () => {
-                const [, , Provider] = useUseCase('', stringUseCase);
-                return (_jsx(Provider, { children: _jsx(A, {}) }));
-            };
-            render(_jsx(B, {}));
-            expect(addReducer).toHaveBeenCalledTimes(1);
-            expect(addReducer).toHaveBeenCalledWith('', 'x');
-            expect(addReducer).toHaveReturnedWith('x');
-            fireEvent.click(screen.getByText(buttonText));
-            expect(addReducer).toHaveBeenCalledTimes(1);
+        return _jsx("button", {
+          onClick: onClick,
+          children: buttonText
         });
-        test('reducer call should not be cached if component is not at rendering phase in child components', () => {
-            const buttonText = 'button';
-            const addReducer = jest.fn((entity, substring) => {
-                return entity + substring;
-            });
-            const stringUseCase = () => {
-                const entityReducers = entityUseCase();
-                return {
-                    ...entityReducers,
-                    add: addReducer,
-                };
-            };
-            const A = () => {
-                const [, { add }] = useUseCase(stringUseCase);
-                const onClick = () => {
-                    add('x');
-                };
-                useMount(() => {
-                    add('x');
-                    add('x');
-                });
-                return _jsx("button", { onClick: onClick, children: buttonText });
-            };
-            const B = () => {
-                const [, , Provider] = useUseCase('', stringUseCase);
-                return (_jsx(Provider, { children: _jsx(A, {}) }));
-            };
-            render(_jsx(B, {}));
-            expect(addReducer).toHaveBeenCalledTimes(2);
-            expect(addReducer).toHaveBeenNthCalledWith(1, '', 'x');
-            expect(addReducer).toHaveBeenNthCalledWith(2, '', 'x');
-            fireEvent.click(screen.getByText(buttonText));
-            expect(addReducer).toHaveBeenCalledTimes(3);
-            expect(addReducer).toHaveBeenNthCalledWith(3, '', 'x');
+      };
+      const B = () => {
+        const _useUseCase38 = useUseCase('', stringUseCase),
+          _useUseCase39 = _slicedToArray(_useUseCase38, 3),
+          Provider = _useUseCase39[2];
+        return _jsx(Provider, {
+          children: _jsx(A, {})
         });
-        test('reducer call should not be cached if entity or parameters have changed in child components', () => {
-            let count = 0;
-            let addedText = 'x';
-            const setButtonText = 'button';
-            const updateButtonText = 'update';
-            const addReducer = jest.fn((entity, substring) => {
-                return entity + substring;
-            });
-            const stringUseCase = () => {
-                const entityReducers = entityUseCase();
-                return {
-                    ...entityReducers,
-                    add: addReducer,
-                };
-            };
-            const A = () => {
-                const [, { add, setEntity }] = useUseCase(stringUseCase);
-                const update = useUpdate();
-                add(addedText);
-                const onSet = () => {
-                    setEntity(`${count++}`);
-                };
-                const onUpdate = () => {
-                    update();
-                };
-                return (_jsxs("div", { children: [_jsx("button", { onClick: onSet, children: setButtonText }), _jsx("button", { onClick: onUpdate, children: updateButtonText })] }));
-            };
-            const B = () => {
-                const [, , Provider] = useUseCase('', stringUseCase);
-                return (_jsx(Provider, { children: _jsx(A, {}) }));
-            };
-            render(_jsx(B, {}));
-            expect(addReducer).toHaveBeenCalledTimes(1);
-            expect(addReducer).toHaveBeenCalledWith('', 'x');
-            fireEvent.click(screen.getByText(setButtonText));
-            expect(addReducer).toHaveBeenCalledTimes(2);
-            expect(addReducer).toHaveBeenCalledWith('0', 'x');
-            expect(addReducer).toHaveReturnedWith('0x');
-            addedText = 'y';
-            fireEvent.click(screen.getByText(updateButtonText));
-            expect(addReducer).toHaveBeenCalledTimes(3);
-            expect(addReducer).toHaveBeenCalledWith('0', 'y');
-            expect(addReducer).toHaveReturnedWith('0y');
-            fireEvent.click(screen.getByText(updateButtonText));
-            expect(addReducer).toHaveBeenCalledTimes(3);
+      };
+      render(_jsx(B, {}));
+      expect(addReducer).toHaveBeenCalledTimes(2);
+      expect(addReducer).toHaveBeenNthCalledWith(1, '', 'x');
+      expect(addReducer).toHaveBeenNthCalledWith(2, '', 'x');
+      fireEvent.click(screen.getByText(buttonText));
+      expect(addReducer).toHaveBeenCalledTimes(3);
+      expect(addReducer).toHaveBeenNthCalledWith(3, '', 'x');
+    });
+    test('reducer call should not be cached if entity or parameters have changed in child components', () => {
+      let count = 0;
+      let addedText = 'x';
+      const setButtonText = 'button';
+      const updateButtonText = 'update';
+      const addReducer = jest.fn((entity, substring) => {
+        return entity + substring;
+      });
+      const stringUseCase = () => {
+        const entityReducers = entityUseCase();
+        return {
+          ...entityReducers,
+          add: addReducer
+        };
+      };
+      const A = () => {
+        const _useUseCase40 = useUseCase(stringUseCase),
+          _useUseCase41 = _slicedToArray(_useUseCase40, 2),
+          _useUseCase41$ = _useUseCase41[1],
+          add = _useUseCase41$.add,
+          setEntity = _useUseCase41$.setEntity;
+        const update = useUpdate();
+        add(addedText);
+        const onSet = () => {
+          setEntity(`${count++}`);
+        };
+        const onUpdate = () => {
+          update();
+        };
+        return _jsxs("div", {
+          children: [_jsx("button", {
+            onClick: onSet,
+            children: setButtonText
+          }), _jsx("button", {
+            onClick: onUpdate,
+            children: updateButtonText
+          })]
         });
-        test('`options.onChange` event should be trigger in orders', () => {
-            let changeTimes = 0;
-            const updateChangeTimes = () => {
-                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, { onChange: onChangeA });
-                return _jsx(Fragment, { children: children });
-            };
-            const B = () => {
-                useUseCase(fileUseCase, { onChange: onChangeB });
-                return _jsx(Fragment, {});
-            };
-            const C = () => {
-                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
-                    onChange: 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(3);
-            expect(onChangeC).toHaveReturnedWith(1);
+      };
+      const B = () => {
+        const _useUseCase42 = useUseCase('', stringUseCase),
+          _useUseCase43 = _slicedToArray(_useUseCase42, 3),
+          Provider = _useUseCase43[2];
+        return _jsx(Provider, {
+          children: _jsx(A, {})
         });
-        test('`options.onChange` should always trigger the latest one in child components', () => {
-            const onFirstChange = jest.fn();
-            const onSecondChange = jest.fn();
-            let onChange = onFirstChange;
-            const firstButtonText = 'first button';
-            const secondButtonText = 'second button';
-            const A = () => {
-                const [, { setPath }] = useUseCase(fileUseCase, {
-                    onChange,
-                });
-                const onFirstClick = () => {
-                    setPath(PATH_1);
-                    onChange = onSecondChange;
-                };
-                const onSecondClick = () => {
-                    setPath('');
-                };
-                return (_jsxs(Fragment, { children: [_jsx("button", { onClick: onFirstClick, children: firstButtonText }), _jsx("button", { onClick: onSecondClick, children: secondButtonText })] }));
-            };
-            const B = () => {
-                const [, , Provider] = useUseCase(defaultFile, fileUseCase);
-                return (_jsx(Provider, { children: _jsx(A, {}) }));
-            };
-            render(_jsx(B, {}));
-            expect(onFirstChange).toHaveBeenCalledTimes(0);
-            fireEvent.click(screen.getByText(firstButtonText));
-            expect(onFirstChange).toHaveBeenCalledTimes(1);
-            expect(onSecondChange).toHaveBeenCalledTimes(0);
-            fireEvent.click(screen.getByText(secondButtonText));
-            expect(onFirstChange).toHaveBeenCalledTimes(1);
-            expect(onSecondChange).toHaveBeenCalledTimes(1);
-            expect(onSecondChange).toHaveBeenLastCalledWith(defaultFile, { ...defaultFile, ext: EXT_1, path: PATH_1 });
+      };
+      render(_jsx(B, {}));
+      expect(addReducer).toHaveBeenCalledTimes(1);
+      expect(addReducer).toHaveBeenCalledWith('', 'x');
+      fireEvent.click(screen.getByText(setButtonText));
+      expect(addReducer).toHaveBeenCalledTimes(2);
+      expect(addReducer).toHaveBeenCalledWith('0', 'x');
+      expect(addReducer).toHaveReturnedWith('0x');
+      addedText = 'y';
+      fireEvent.click(screen.getByText(updateButtonText));
+      expect(addReducer).toHaveBeenCalledTimes(3);
+      expect(addReducer).toHaveBeenCalledWith('0', 'y');
+      expect(addReducer).toHaveReturnedWith('0y');
+      fireEvent.click(screen.getByText(updateButtonText));
+      expect(addReducer).toHaveBeenCalledTimes(3);
+    });
+    test('`options.onChange` event should be trigger in orders', () => {
+      let changeTimes = 0;
+      const updateChangeTimes = () => {
+        return ++changeTimes;
+      };
+      const onChangeA = jest.fn(updateChangeTimes);
+      const onChangeB = jest.fn(updateChangeTimes);
+      const onChangeC = jest.fn(updateChangeTimes);
+      const buttonText = 'my button';
+      const A = _ref5 => {
+        let children = _ref5.children;
+        useUseCase(fileUseCase, {
+          onChange: onChangeA
         });
-        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: '',
-            });
+        return _jsx(Fragment, {
+          children: children
         });
-        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(3);
-            expect(onChangeC).toHaveReturnedWith(1);
+      };
+      const B = () => {
+        useUseCase(fileUseCase, {
+          onChange: onChangeB
         });
-        test('`options.watch` should trigger the latest one in child components', () => {
-            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 [, , Provider] = useUseCase(defaultFile, fileUseCase);
-                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,
-            });
+        return _jsx(Fragment, {});
+      };
+      const C = () => {
+        const _useUseCase44 = useUseCase(defaultFile, fileUseCase, {
+            onChange: onChangeC
+          }),
+          _useUseCase45 = _slicedToArray(_useUseCase44, 3),
+          setPath = _useUseCase45[1].setPath,
+          Provider = _useUseCase45[2];
+        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(3);
+      expect(onChangeC).toHaveReturnedWith(1);
     });
-    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('`options.onChange` should always trigger the latest one in child components', () => {
+      const onFirstChange = jest.fn();
+      const onSecondChange = jest.fn();
+      let onChange = onFirstChange;
+      const firstButtonText = 'first button';
+      const secondButtonText = 'second button';
+      const A = () => {
+        const _useUseCase46 = useUseCase(fileUseCase, {
+            onChange
+          }),
+          _useUseCase47 = _slicedToArray(_useUseCase46, 2),
+          setPath = _useUseCase47[1].setPath;
+        const onFirstClick = () => {
+          setPath(PATH_1);
+          onChange = onSecondChange;
+        };
+        const onSecondClick = () => {
+          setPath('');
+        };
+        return _jsxs(Fragment, {
+          children: [_jsx("button", {
+            onClick: onFirstClick,
+            children: firstButtonText
+          }), _jsx("button", {
+            onClick: onSecondClick,
+            children: secondButtonText
+          })]
         });
-        test('returned reducer should work', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase);
-            });
-            const { current: reducers } = result;
-            const { add } = reducers;
-            expect(add(1, 2)).toBe(3);
+      };
+      const B = () => {
+        const _useUseCase48 = useUseCase(defaultFile, fileUseCase),
+          _useUseCase49 = _slicedToArray(_useUseCase48, 3),
+          Provider = _useUseCase49[2];
+        return _jsx(Provider, {
+          children: _jsx(A, {})
         });
-        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);
+      };
+      render(_jsx(B, {}));
+      expect(onFirstChange).toHaveBeenCalledTimes(0);
+      fireEvent.click(screen.getByText(firstButtonText));
+      expect(onFirstChange).toHaveBeenCalledTimes(1);
+      expect(onSecondChange).toHaveBeenCalledTimes(0);
+      fireEvent.click(screen.getByText(secondButtonText));
+      expect(onFirstChange).toHaveBeenCalledTimes(1);
+      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 _useUseCase50 = useUseCase(fileUseCase, {
+            watch: {
+              ext: onExtChange
+            }
+          }),
+          _useUseCase51 = _slicedToArray(_useUseCase50, 2),
+          setPath = _useUseCase51[1].setPath;
+        const onFirstClick = () => {
+          setPath(PATH_1);
+        };
+        return _jsx("button", {
+          onClick: onFirstClick,
+          children: firstButtonText
         });
-        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);
+      };
+      const B = () => {
+        const _useUseCase52 = useUseCase(defaultFile, fileUseCase, {}),
+          _useUseCase53 = _slicedToArray(_useUseCase52, 3),
+          Provider = _useUseCase53[2];
+        return _jsx(Provider, {
+          children: _jsx(A, {})
         });
-        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);
+      };
+      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 = _ref6 => {
+        let children = _ref6.children;
+        useUseCase(fileUseCase, {
+          watch: {
+            ext: onChangeA
+          }
         });
-        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);
+        return _jsx(Fragment, {
+          children: children
         });
-        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);
+      };
+      const B = () => {
+        useUseCase(fileUseCase, {
+          watch: {
+            ext: onChangeB
+          }
         });
-        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);
+        return _jsx(Fragment, {});
+      };
+      const C = () => {
+        const _useUseCase54 = useUseCase(defaultFile, fileUseCase, {
+            watch: {
+              ext: onChangeC
+            }
+          }),
+          _useUseCase55 = _slicedToArray(_useUseCase54, 3),
+          setPath = _useUseCase55[1].setPath,
+          Provider = _useUseCase55[2];
+        const onFirstClick = () => {
+          setPath(PATH_1);
+        };
+        return _jsxs(Provider, {
+          children: [_jsx(A, {
+            children: _jsx(B, {})
+          }), _jsx("button", {
+            onClick: onFirstClick,
+            children: buttonText
+          })]
         });
-        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);
+      };
+      render(_jsx(C, {}));
+      expect(changeTimes).toBe(0);
+      fireEvent.click(screen.getByText(buttonText));
+      expect(onChangeA).toHaveReturnedWith(2);
+      expect(onChangeB).toHaveReturnedWith(3);
+      expect(onChangeC).toHaveReturnedWith(1);
+    });
+    test('`options.watch` should trigger the latest one in child components', () => {
+      const onFirstExtChange = jest.fn();
+      const onSecondExtChange = jest.fn();
+      let onExtChange = onFirstExtChange;
+      const firstButtonText = 'first button';
+      const secondButtonText = 'second button';
+      const A = () => {
+        const _useUseCase56 = useUseCase(fileUseCase, {
+            watch: {
+              ext: onExtChange
+            }
+          }),
+          _useUseCase57 = _slicedToArray(_useUseCase56, 2),
+          setPath = _useUseCase57[1].setPath;
+        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
+          })]
         });
-        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);
+      };
+      const B = () => {
+        const _useUseCase58 = useUseCase(defaultFile, fileUseCase),
+          _useUseCase59 = _slicedToArray(_useUseCase58, 3),
+          Provider = _useUseCase59[2];
+        return _jsx(Provider, {
+          children: _jsx(A, {})
         });
-        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);
+      };
+      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`', () => {
+      const _renderHook32 = renderHook(() => {
+          return useUseCase(mathUseCase);
+        }),
+        result = _renderHook32.result;
+      const reducers = result.current;
+      expect(Array.isArray(reducers)).toBe(false);
+    });
+    test('returned reducer should work', () => {
+      const _renderHook33 = renderHook(() => {
+          return useUseCase(mathUseCase);
+        }),
+        result = _renderHook33.result;
+      const reducers = result.current;
+      const add = reducers.add;
+      expect(add(1, 2)).toBe(3);
+    });
+    test('`usecase` should be called only once if deps has not provided', () => {
+      const mockUseCase = jest.fn(mathUseCase);
+      const _renderHook34 = renderHook(() => {
+          return useUseCase(mockUseCase);
+        }),
+        rerender = _renderHook34.rerender;
+      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 _renderHook35 = renderHook(() => {
+          return useUseCase(mockUseCase, {}, [1, 'x']);
+        }),
+        rerender = _renderHook35.rerender;
+      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 _renderHook36 = renderHook(() => {
+          return useUseCase(mockUseCase, {}, [i++, 'x']);
+        }),
+        rerender = _renderHook36.rerender;
+      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 _useUseCase60 = useUseCase(mathUseCase),
+          subtraction = _useUseCase60.subtraction;
+        const update = useUpdate();
+        const onClick = () => {
+          update();
+        };
+        subtraction(5, 3);
+        return _jsx("button", {
+          onClick: onClick,
+          children: buttonText
         });
-        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);
+      };
+      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 _useUseCase61 = useUseCase(mathUseCase),
+          subtraction = _useUseCase61.subtraction;
+        const onClick = () => {
+          subtraction(5, 3);
+        };
+        useMount(() => {
+          subtraction(5, 3);
+          subtraction(5, 3);
         });
-        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);
+        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 _useUseCase62 = useUseCase(mathUseCase),
+          subtraction = _useUseCase62.subtraction;
+        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 _renderHook37 = renderHook(() => {
+          return useUseCase(mathUseCase, {
+            extraValue: 5
+          });
+        }),
+        result = _renderHook37.result;
+      const reducers = result.current;
+      const add = reducers.add;
+      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 _renderHook38 = renderHook(() => {
+          const _useState7 = useState(0),
+            _useState8 = _slicedToArray(_useState7, 2),
+            extraValue = _useState8[0],
+            setExtraValue = _useState8[1];
+          const reducers = useUseCase(mathUseCase, {
+            extraValue
+          });
+          useUpdateEffect(() => {
+            onUpdate();
+          }, [reducers]);
+          useDeepCompareUpdate(() => {
+            onDeepUpdate();
+          }, [reducers]);
+          return setExtraValue;
+        }),
+        result = _renderHook38.result;
+      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 _renderHook39 = renderHook(() => {
+          const _useState9 = useState(0),
+            _useState0 = _slicedToArray(_useState9, 2),
+            extraValue = _useState0[0],
+            setExtraValue = _useState0[1];
+          const reducers = useUseCase(mathUseCase, {
+            extraValue
+          }, [extraValue]);
+          useUpdateEffect(() => {
+            onUpdate();
+          }, [reducers]);
+          useDeepCompareUpdate(() => {
+            onDeepUpdate();
+          }, [reducers]);
+          return setExtraValue;
+        }),
+        result = _renderHook39.result;
+      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 _renderHook40 = renderHook(() => {
+          const _useState1 = useState(0),
+            _useState10 = _slicedToArray(_useState1, 2),
+            extraValue = _useState10[0],
+            setExtraValue = _useState10[1];
+          const reducers = useUseCase(mathUseCase, {
+            extraValue
+          }, []);
+          useUpdateEffect(() => {
+            onUpdate();
+          }, [reducers]);
+          useDeepCompareUpdate(() => {
+            onDeepUpdate();
+          }, [reducers]);
+          return setExtraValue;
+        }),
+        result = _renderHook40.result;
+      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);
+    });
+  });
+});