@mic-rexjs/usecases-react 1.4.0 → 1.5.0

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

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { objectUseCase, } from '@mic-rexjs/usecases';
+import { objectUseCase, entityUseCase, } from '@mic-rexjs/usecases';
 import { describe, expect, jest, test } from '@jest/globals';
 import { renderHook, act, render, fireEvent, screen } from '@testing-library/react';
 import { useUseCase } from '.';
@@ -34,9 +34,9 @@ const fileUseCase = (options = {}) => {
         const size = 2000;
         yield* setPath(entity, path);
         await Promise.resolve(null);
-        yield (prevEntity) => {
+        yield (oldEntity) => {
             return {
-                ...prevEntity,
+                ...oldEntity,
                 size,
             };
         };
@@ -58,6 +58,9 @@ const mathUseCase = (options = {}) => {
     };
     return { add, subtraction };
 };
+const fieldPathUseCase = () => {
+    return objectUseCase();
+};
 const Child = ({ textPrefix = '', onUpdate, onPathChange, onUndefinedEntity }) => {
     const [file, { setPath }] = useUseCase(fileUseCase);
     const { path, ext } = file || {};
@@ -121,31 +124,31 @@ describe('useUseCase', () => {
             const { result } = renderHook(() => {
                 return useUseCase(defaultFile, fileUseCase);
             });
-            const { current: context } = result;
-            expect(context).toHaveLength(3);
+            const { current: cores } = result;
+            expect(cores).toHaveLength(3);
         });
         test('`entity` should equal `defaultFile`', () => {
             const { result } = renderHook(() => {
                 return useUseCase(defaultFile, fileUseCase);
             });
-            const { current: context } = result;
-            const [entity] = context;
+            const { current: cores } = result;
+            const [entity] = cores;
             expect(entity).toBe(defaultFile);
         });
         test('`reducers` should be returned as an object', () => {
             const { result } = renderHook(() => {
                 return useUseCase(defaultFile, fileUseCase);
             });
-            const { current: context } = result;
-            const [, reducers] = context;
+            const { current: cores } = result;
+            const [, reducers] = cores;
             expect(typeof reducers).toBe('object');
         });
         test('`Provider` should be returned as a function', () => {
             const { result } = renderHook(() => {
                 return useUseCase(defaultFile, fileUseCase);
             });
-            const { current: context } = result;
-            const [, , Provider] = context;
+            const { current: cores } = result;
+            const [, , Provider] = cores;
             expect(typeof Provider).toBe('function');
         });
         test('after call non-generator reducer, it should not trigger update', () => {
@@ -189,14 +192,14 @@ describe('useUseCase', () => {
                 });
                 return useUseCase(defaultFile, fileUseCase);
             });
-            const { current: context } = result;
-            const [entity, reducers] = context;
+            const { current: cores } = result;
+            const [entity, reducers] = cores;
             const { setPath, setEntity } = reducers;
             act(() => {
                 setPath(PATH_1);
                 setEntity({ size: 5000 });
             });
-            expect(result.current).not.toBe(context);
+            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);
@@ -216,14 +219,14 @@ describe('useUseCase', () => {
                 });
                 return useUseCase(defaultFile, fileUseCase);
             });
-            const { current: context } = result;
-            const [entity, reducers] = context;
+            const { current: cores } = result;
+            const [entity, reducers] = cores;
             const { readFile } = reducers;
             const promise = act(() => {
                 return readFile(PATH_1);
             });
-            expect(result.current).toBe(context);
-            expect(result.current).toEqual(context);
+            expect(result.current).toBe(cores);
+            expect(result.current).toEqual(cores);
             expect(onUpdate).toHaveBeenCalledTimes(0);
             await promise;
             expect(result.current[0]).not.toBe(entity);
@@ -242,8 +245,8 @@ describe('useUseCase', () => {
                 });
                 return useUseCase(defaultFile, fileUseCase);
             });
-            const { current: context } = result;
-            const [, reducers] = context;
+            const { current: cores } = result;
+            const [, reducers] = cores;
             const { init } = reducers;
             act(() => {
                 init({ ...defaultFile, size: 5000 });
@@ -261,8 +264,8 @@ describe('useUseCase', () => {
                 });
                 return useUseCase(file, fileUseCase, { stateless: true });
             });
-            const { current: context } = result;
-            const [, { setPath }] = context;
+            const { current: cores } = result;
+            const [, { setPath }] = cores;
             setPath(PATH_1);
             expect(onUpdate).toHaveBeenCalledTimes(0);
             expect(result.current[0].path).toBe('');
@@ -279,14 +282,14 @@ describe('useUseCase', () => {
                 });
                 return useUseCase(defaultFile, fileUseCase, { stateless: true });
             });
-            const { current: context } = result;
-            const [, reducers] = context;
+            const { current: cores } = result;
+            const [, reducers] = cores;
             const { setPath } = reducers;
             act(() => {
                 setPath(PATH_1);
             });
-            expect(result.current).toBe(context);
-            expect(result.current).toEqual(context);
+            expect(result.current).toBe(cores);
+            expect(result.current).toEqual(cores);
             expect(onUpdate).toHaveBeenCalledTimes(0);
         });
         test('`options.onChange` should be trigger when entity has changed', () => {
@@ -294,9 +297,8 @@ describe('useUseCase', () => {
             const { result } = renderHook(() => {
                 return useUseCase(defaultFile, fileUseCase, { onChange });
             });
-            ``;
-            const { current: context } = result;
-            const [, reducers] = context;
+            const { current: cores } = result;
+            const [, reducers] = cores;
             const { setPath } = reducers;
             expect(onChange).toHaveBeenCalledTimes(0);
             act(() => {
@@ -312,8 +314,8 @@ describe('useUseCase', () => {
                     options: { pathPrefix: '123/' },
                 });
             });
-            const { current: context } = result;
-            const [{ path }, reducers] = context;
+            const { current: cores } = result;
+            const [{ path }, reducers] = cores;
             const { setPath } = reducers;
             expect(path).toBe('');
             act(() => {
@@ -344,6 +346,33 @@ describe('useUseCase', () => {
             expect(onDeepUpdate).toHaveBeenCalledTimes(0);
         });
         test('when `entity` change, it should trigger watchers', () => {
+            const onPathChange = jest.fn();
+            const onSizeChange = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase(defaultFile, fileUseCase, {
+                    watch: {
+                        path: onPathChange,
+                        size: onSizeChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setPath }] = cores;
+            expect(onPathChange).toHaveBeenCalledTimes(0);
+            act(() => {
+                setPath(PATH_1);
+            });
+            expect(onPathChange).toHaveBeenCalledTimes(1);
+            expect(onSizeChange).toHaveBeenCalledTimes(0);
+            expect(onPathChange).toHaveBeenLastCalledWith({
+                fieldPaths: ['path'],
+                newEntity: { ...defaultFile, path: PATH_1, ext: EXT_1 },
+                oldEntity: defaultFile,
+                newValue: PATH_1,
+                oldValue: '',
+            });
+        });
+        test('watcher should be updated after `entity` change', () => {
             const onPathChange1 = jest.fn();
             const onPathChange2 = jest.fn();
             let onPathChange = onPathChange1;
@@ -354,8 +383,8 @@ describe('useUseCase', () => {
                     },
                 });
             });
-            const { current: context } = result;
-            const [, { setPath, setEntity }] = context;
+            const { current: cores } = result;
+            const [, { setPath, setEntity }] = cores;
             onPathChange = onPathChange2;
             expect(onPathChange1).toHaveBeenCalledTimes(0);
             act(() => {
@@ -363,12 +392,24 @@ describe('useUseCase', () => {
                 setEntity({ size: 5000 });
             });
             expect(onPathChange1).toHaveBeenCalledTimes(1);
-            expect(onPathChange1).toHaveBeenLastCalledWith({ ...defaultFile, path: PATH_1, ext: EXT_1 }, defaultFile);
+            expect(onPathChange1).toHaveBeenLastCalledWith({
+                fieldPaths: ['path'],
+                newEntity: { ...defaultFile, path: PATH_1, ext: EXT_1 },
+                oldEntity: defaultFile,
+                newValue: PATH_1,
+                oldValue: '',
+            });
             act(() => {
                 setPath('');
             });
             expect(onPathChange2).toHaveBeenCalledTimes(1);
-            expect(onPathChange2).toHaveBeenLastCalledWith({ ...defaultFile, size: 5000 }, { ...defaultFile, path: PATH_1, size: 5000, ext: EXT_1 });
+            expect(onPathChange2).toHaveBeenLastCalledWith({
+                fieldPaths: ['path'],
+                newEntity: { ...defaultFile, size: 5000 },
+                oldEntity: { ...defaultFile, path: PATH_1, size: 5000, ext: EXT_1 },
+                newValue: '',
+                oldValue: PATH_1,
+            });
         });
         test('when `deps` has changed, it should trigger update', () => {
             const onUpdate = jest.fn();
@@ -640,22 +681,31 @@ describe('useUseCase', () => {
             expect(onFirstExtChange).toHaveBeenCalledTimes(0);
             fireEvent.click(screen.getByText(firstButtonText));
             expect(onFirstExtChange).toHaveBeenCalledTimes(1);
-            expect(onFirstExtChange).toHaveBeenLastCalledWith({ ...defaultFile, ext: EXT_1, path: PATH_1 }, defaultFile);
+            expect(onFirstExtChange).toHaveBeenLastCalledWith({
+                fieldPaths: ['ext'],
+                newEntity: { ...defaultFile, ext: EXT_1, path: PATH_1 },
+                oldEntity: defaultFile,
+                newValue: EXT_1,
+                oldValue: '',
+            });
             expect(onParentExtChange).toHaveBeenCalledTimes(1);
             expect(onSecondExtChange).toHaveBeenCalledTimes(0);
             fireEvent.click(screen.getByText(secondButtonText));
             expect(onSecondExtChange).toHaveBeenCalledTimes(1);
-            expect(onSecondExtChange).toHaveBeenLastCalledWith(defaultFile, {
-                ...defaultFile,
-                ext: EXT_1,
-                path: PATH_1,
+            expect(onSecondExtChange).toHaveBeenLastCalledWith({
+                fieldPaths: ['ext'],
+                newEntity: defaultFile,
+                oldEntity: { ...defaultFile, ext: EXT_1, path: PATH_1 },
+                newValue: '',
+                oldValue: EXT_1,
             });
             expect(onFirstExtChange).toHaveBeenCalledTimes(1);
             expect(onParentExtChange).toHaveBeenCalledTimes(2);
         });
         test('`options.watch` should be trigger in orders', () => {
             let changeTimes = 0;
-            const updateChangeTimes = () => {
+            const updateChangeTimes = (e) => {
+                void e;
                 return ++changeTimes;
             };
             const onChangeA = jest.fn(updateChangeTimes);
@@ -696,5 +746,407 @@ describe('useUseCase', () => {
             expect(onChangeB).toHaveReturnedWith(1);
             expect(onChangeC).toHaveReturnedWith(3);
         });
+        test('`options.watch` should work with array field path of array', () => {
+            const onExtChange = jest.fn();
+            const onSizeChange = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase({}, fieldPathUseCase, {
+                    watch: {
+                        'list.ext': onExtChange,
+                        'list.size': onSizeChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setEntity }] = cores;
+            act(() => {
+                setEntity({ list: [defaultFile] });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(1);
+            expect(onSizeChange).toHaveBeenCalledTimes(1);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '0', 'ext'],
+                newEntity: { list: [defaultFile] },
+                oldEntity: {},
+                newValue: '',
+                oldValue: void 0,
+            });
+            expect(onSizeChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '0', 'size'],
+                newEntity: { list: [defaultFile] },
+                oldEntity: {},
+                newValue: 0,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity({ list: [{ ...defaultFile, ext: EXT_1 }] });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(2);
+            expect(onSizeChange).toHaveBeenCalledTimes(1);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '0', 'ext'],
+                newEntity: { list: [{ ...defaultFile, ext: EXT_1 }] },
+                oldEntity: { list: [defaultFile] },
+                newValue: EXT_1,
+                oldValue: '',
+            });
+            act(() => {
+                setEntity({
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(3);
+            expect(onSizeChange).toHaveBeenCalledTimes(2);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '1', 'ext'],
+                newEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                },
+                oldEntity: { list: [{ ...defaultFile, ext: EXT_1 }] },
+                newValue: EXT_2,
+                oldValue: void 0,
+            });
+            expect(onSizeChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '1', 'size'],
+                newEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                },
+                oldEntity: { list: [{ ...defaultFile, ext: EXT_1 }] },
+                newValue: 0,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity({
+                    nestedList: [],
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(3);
+            expect(onSizeChange).toHaveBeenCalledTimes(2);
+            act(() => {
+                setEntity(() => {
+                    return {
+                        list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                    };
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(6);
+            expect(onSizeChange).toHaveBeenCalledTimes(3);
+            expect(onExtChange).toHaveBeenNthCalledWith(4, {
+                fieldPaths: ['list', '0', 'ext'],
+                newEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                oldEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                    nestedList: [],
+                },
+                newValue: EXT_2,
+                oldValue: EXT_1,
+            });
+            expect(onExtChange).toHaveBeenNthCalledWith(5, {
+                fieldPaths: ['list', '1', 'ext'],
+                newEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                oldEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                    nestedList: [],
+                },
+                newValue: EXT_1,
+                oldValue: EXT_2,
+            });
+            expect(onExtChange).toHaveBeenNthCalledWith(6, {
+                fieldPaths: ['list', '2', 'ext'],
+                newEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                oldEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                    nestedList: [],
+                },
+                newValue: '',
+                oldValue: void 0,
+            });
+            expect(onSizeChange).toHaveBeenCalledWith({
+                fieldPaths: ['list', '2', 'size'],
+                newEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                oldEntity: {
+                    list: [
+                        { ...defaultFile, ext: EXT_1 },
+                        { ...defaultFile, ext: EXT_2 },
+                    ],
+                    nestedList: [],
+                },
+                newValue: 0,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity(() => {
+                    return {};
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(9);
+            expect(onSizeChange).toHaveBeenCalledTimes(6);
+            expect(onExtChange).toHaveBeenNthCalledWith(7, {
+                fieldPaths: ['list', '0', 'ext'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: EXT_2,
+            });
+            expect(onExtChange).toHaveBeenNthCalledWith(8, {
+                fieldPaths: ['list', '1', 'ext'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: EXT_1,
+            });
+            expect(onExtChange).toHaveBeenNthCalledWith(9, {
+                fieldPaths: ['list', '2', 'ext'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: '',
+            });
+            expect(onSizeChange).toHaveBeenNthCalledWith(4, {
+                fieldPaths: ['list', '0', 'size'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: 0,
+            });
+            expect(onSizeChange).toHaveBeenNthCalledWith(5, {
+                fieldPaths: ['list', '1', 'size'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: 0,
+            });
+            expect(onSizeChange).toHaveBeenNthCalledWith(6, {
+                fieldPaths: ['list', '2', 'size'],
+                newEntity: {},
+                oldEntity: {
+                    list: [{ ...defaultFile, ext: EXT_2 }, { ...defaultFile, ext: EXT_1 }, defaultFile],
+                },
+                newValue: void 0,
+                oldValue: 0,
+            });
+        });
+        test('`options.watch` should work with field path of array length', () => {
+            const onEntityLengthChange = jest.fn();
+            const onListLengthChange = jest.fn();
+            const lengthUseCase = () => {
+                return entityUseCase();
+            };
+            const { result } = renderHook(() => {
+                return useUseCase([], lengthUseCase, {
+                    watch: {
+                        length: onEntityLengthChange,
+                        'list.length': onListLengthChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setEntity }] = cores;
+            expect(onEntityLengthChange).toHaveBeenCalledTimes(0);
+            expect(onListLengthChange).toHaveBeenCalledTimes(0);
+            act(() => {
+                setEntity([{ list: [defaultFile, defaultFile] }]);
+            });
+            expect(onEntityLengthChange).toHaveBeenCalledTimes(1);
+            expect(onListLengthChange).toHaveBeenCalledTimes(1);
+            expect(onEntityLengthChange).toHaveBeenCalledWith({
+                fieldPaths: ['length'],
+                newEntity: [{ list: [defaultFile, defaultFile] }],
+                oldEntity: [],
+                newValue: 1,
+                oldValue: 0,
+            });
+            expect(onListLengthChange).toHaveBeenCalledWith({
+                fieldPaths: ['0', 'list', 'length'],
+                newEntity: [{ list: [defaultFile, defaultFile] }],
+                oldEntity: [],
+                newValue: 2,
+                oldValue: void 0,
+            });
+        });
+        test('`options.watch` should work with field path of nested array', () => {
+            const onChange = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase({}, fieldPathUseCase, {
+                    watch: {
+                        'nestedList.size': onChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setEntity }] = cores;
+            expect(onChange).toHaveBeenCalledTimes(0);
+            act(() => {
+                setEntity({ nestedList: [[[defaultFile]]] });
+            });
+            expect(onChange).toHaveBeenCalledTimes(1);
+            expect(onChange).toHaveBeenCalledWith({
+                fieldPaths: ['nestedList', '0', '0', '0', 'size'],
+                newEntity: { nestedList: [[[defaultFile]]] },
+                oldEntity: {},
+                newValue: 0,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity({
+                    nestedList: [
+                        [
+                            [
+                                { ...defaultFile, size: 100 },
+                                { ...defaultFile, size: 200 },
+                            ],
+                        ],
+                        [[{ ...defaultFile, size: 300 }]],
+                    ],
+                });
+            });
+            expect(onChange).toHaveBeenCalledTimes(4);
+            expect(onChange).toHaveBeenNthCalledWith(2, {
+                fieldPaths: ['nestedList', '0', '0', '0', 'size'],
+                newEntity: {
+                    nestedList: [
+                        [
+                            [
+                                { ...defaultFile, size: 100 },
+                                { ...defaultFile, size: 200 },
+                            ],
+                        ],
+                        [[{ ...defaultFile, size: 300 }]],
+                    ],
+                },
+                oldEntity: { nestedList: [[[defaultFile]]] },
+                newValue: 100,
+                oldValue: 0,
+            });
+            expect(onChange).toHaveBeenNthCalledWith(3, {
+                fieldPaths: ['nestedList', '0', '0', '1', 'size'],
+                newEntity: {
+                    nestedList: [
+                        [
+                            [
+                                { ...defaultFile, size: 100 },
+                                { ...defaultFile, size: 200 },
+                            ],
+                        ],
+                        [[{ ...defaultFile, size: 300 }]],
+                    ],
+                },
+                oldEntity: { nestedList: [[[defaultFile]]] },
+                newValue: 200,
+                oldValue: void 0,
+            });
+            expect(onChange).toHaveBeenNthCalledWith(4, {
+                fieldPaths: ['nestedList', '1', '0', '0', 'size'],
+                newEntity: {
+                    nestedList: [
+                        [
+                            [
+                                { ...defaultFile, size: 100 },
+                                { ...defaultFile, size: 200 },
+                            ],
+                        ],
+                        [[{ ...defaultFile, size: 300 }]],
+                    ],
+                },
+                oldEntity: { nestedList: [[[defaultFile]]] },
+                newValue: 300,
+                oldValue: void 0,
+            });
+        });
+        test('`options.watch` should work with field path of object', () => {
+            const onExtChange = jest.fn();
+            const onSizeChange = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase({}, fieldPathUseCase, {
+                    watch: {
+                        'obj.file.ext': onExtChange,
+                        'obj.file.size': onSizeChange,
+                    },
+                });
+            });
+            const { current: cores } = result;
+            const [, { setEntity }] = cores;
+            expect(onExtChange).toHaveBeenCalledTimes(0);
+            act(() => {
+                setEntity({
+                    obj: {
+                        file: {
+                            ext: EXT_1,
+                        },
+                    },
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(1);
+            expect(onSizeChange).toHaveBeenCalledTimes(0);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['obj', 'file', 'ext'],
+                newEntity: {
+                    obj: {
+                        file: {
+                            ext: EXT_1,
+                        },
+                    },
+                },
+                oldEntity: {},
+                newValue: EXT_1,
+                oldValue: void 0,
+            });
+            act(() => {
+                setEntity(() => {
+                    return {};
+                });
+            });
+            expect(onExtChange).toHaveBeenCalledTimes(2);
+            expect(onSizeChange).toHaveBeenCalledTimes(0);
+            expect(onExtChange).toHaveBeenCalledWith({
+                fieldPaths: ['obj', 'file', 'ext'],
+                newEntity: {},
+                oldEntity: {
+                    obj: {
+                        file: {
+                            ext: EXT_1,
+                        },
+                    },
+                },
+                newValue: void 0,
+                oldValue: EXT_1,
+            });
+        });
     });
 });