@mic-rexjs/usecases-react 1.3.36 → 1.4.0

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

@@ -294,6 +294,7 @@ describe('useUseCase', () => {
             const { result } = renderHook(() => {
                 return useUseCase(defaultFile, fileUseCase, { onChange });
             });
+            ``;
             const { current: context } = result;
             const [, reducers] = context;
             const { setPath } = reducers;
@@ -414,72 +415,122 @@ describe('useUseCase', () => {
             expect(onDeepUpdate).toHaveBeenCalledTimes(0);
         });
     });
-    describe('`useUseCase` should work with 1+ argument on accessor mode', () => {
-        test('check `context.length`', () => {
+    describe('`useUseCase` should work with 1+ arguments on non-entity mode', () => {
+        test('`entity` should equal `defaultFile`', () => {
             const { result } = renderHook(() => {
-                return useUseCase(fileUseCase);
+                return useUseCase(mathUseCase);
             });
-            const { current: context } = result;
-            expect(context).toHaveLength(2);
+            const { current: reducers } = result;
+            expect(Array.isArray(reducers)).toBe(false);
         });
-        test('`entity` should be `undefined`', () => {
+        test('returned reducer should work', () => {
             const { result } = renderHook(() => {
-                return useUseCase(fileUseCase);
+                return useUseCase(mathUseCase);
             });
-            const { current: context } = result;
-            const [entity] = context;
-            expect(entity).toBe(void 0);
+            const { current: reducers } = result;
+            const { add } = reducers;
+            expect(add(1, 2)).toBe(3);
         });
-        test('`reducers` should be returned as an object', () => {
+        test('`options.extraValue` should be added after call `add` method', () => {
             const { result } = renderHook(() => {
-                return useUseCase(fileUseCase);
+                return useUseCase(mathUseCase, { extraValue: 5 });
             });
-            const { current: context } = result;
-            const [, reducers] = context;
-            expect(typeof reducers).toBe('object');
+            const { current: reducers } = result;
+            const { add } = reducers;
+            expect(add(1, 2)).toBe(8);
         });
-        test('`yield entity` should not trigger update', () => {
+        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();
-                });
-                return useUseCase(fileUseCase);
+                }, [reducers]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [reducers]);
+                return setExtraValue;
             });
-            const { current: context } = result;
-            const [, reducers] = context;
-            const { setPath } = reducers;
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
             act(() => {
-                setPath(PATH_1);
+                result.current(3);
             });
-            expect(result.current).toBe(context);
-            expect(result.current).toEqual(context);
             expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
         });
-        test('should work within <Child />', () => {
+        test('when `deps` change, it should update reducers', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [extraValue, setExtraValue] = useState(0);
+                const reducers = useUseCase(mathUseCase, { extraValue }, [extraValue]);
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [reducers]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [reducers]);
+                return setExtraValue;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current(3);
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(1);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(1);
+        });
+        test('empty `deps` should not update reducers', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [extraValue, setExtraValue] = useState(0);
+                const reducers = useUseCase(mathUseCase, { extraValue }, []);
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [reducers]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [reducers]);
+                return setExtraValue;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current(3);
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('should not trigger update', () => {
+            const onUpdate = jest.fn();
+            render(_jsx(MathParent, { onUpdate: onUpdate }));
+            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+        });
+    });
+    describe('`useUseCase` should work with 1+ arguments on context mode', () => {
+        test('should work within <Child /> which it is under <Parent />', () => {
             const textPrefix = '>>';
-            const onUpdate1 = jest.fn();
-            const onPathChange1 = jest.fn();
-            const onUndefinedEntity1 = jest.fn();
-            const onUpdate2 = jest.fn();
-            const onPathChange2 = jest.fn();
-            const onUndefinedEntity2 = jest.fn();
+            const onUpdate = jest.fn();
+            const onPathChange = jest.fn();
+            const onUndefinedEntity = jest.fn();
             const onSetPath = jest.fn(() => {
                 return PATH_1;
             });
-            render(_jsxs("div", { children: [_jsx(Parent, { onSetPath: onSetPath, children: _jsx(Child, { textPrefix: textPrefix, onUpdate: onUpdate1, onPathChange: onPathChange1, onUndefinedEntity: onUndefinedEntity1 }) }), _jsx(Child, { onUpdate: onUpdate2, onPathChange: onPathChange2, onUndefinedEntity: onUndefinedEntity2 })] }));
+            render(_jsx("div", { children: _jsx(Parent, { onSetPath: onSetPath, children: _jsx(Child, { textPrefix: textPrefix, onUpdate: onUpdate, onPathChange: onPathChange, onUndefinedEntity: onUndefinedEntity }) }) }));
             fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
             expect(onSetPath).toHaveBeenCalledTimes(1);
-            expect(onUpdate1).toHaveBeenCalledTimes(1);
-            expect(onPathChange1).toHaveBeenCalledWith(PATH_1);
+            expect(onUpdate).toHaveBeenCalledTimes(1);
+            expect(onPathChange).toHaveBeenCalledWith(PATH_1);
             fireEvent.click(screen.getByText(textPrefix + CHILD_BUTTON_TEXT));
             expect(onSetPath).toHaveBeenCalledTimes(1);
-            expect(onUpdate1).toHaveBeenCalledTimes(2);
-            expect(onPathChange1).toHaveBeenCalledWith('');
-            expect(onUpdate2).toHaveBeenCalledTimes(0);
-            expect(onPathChange2).toHaveBeenCalledTimes(0);
-            expect(onUndefinedEntity1).toHaveBeenCalledTimes(0);
-            expect(onUndefinedEntity2).toHaveBeenCalledTimes(1);
+            expect(onUpdate).toHaveBeenCalledTimes(2);
+            expect(onPathChange).toHaveBeenCalledWith('');
+            expect(onUndefinedEntity).toHaveBeenCalledTimes(0);
         });
         test('`options.onChange` event should be trigger at child elements', () => {
             const onFirstChange = jest.fn();
@@ -522,6 +573,39 @@ describe('useUseCase', () => {
             expect(onFirstChange).toHaveBeenCalledTimes(1);
             expect(onParentPathChange).toHaveBeenCalledTimes(2);
         });
+        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(1);
+            expect(onChangeC).toHaveReturnedWith(3);
+        });
         test('`options.watch` should be trigger at child elements', () => {
             const onFirstExtChange = jest.fn();
             const onSecondExtChange = jest.fn();
@@ -569,102 +653,48 @@ describe('useUseCase', () => {
             expect(onFirstExtChange).toHaveBeenCalledTimes(1);
             expect(onParentExtChange).toHaveBeenCalledTimes(2);
         });
-    });
-    describe('`useUseCase` should work with 1+ arguments on non-entity mode', () => {
-        test('`entity` should equal `defaultFile`', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase);
-            });
-            const { current: reducers } = result;
-            expect(typeof reducers).toBe('object');
-        });
-        test('returned reducer should work', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase);
-            });
-            const { current: reducers } = result;
-            const { add } = reducers;
-            expect(add(1, 2)).toBe(3);
-        });
-        test('`options.extraValue` should be added after call `add` method', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase, { extraValue: 5 });
-            });
-            const { current: reducers } = result;
-            const { add } = reducers;
-            expect(add(1, 2)).toBe(8);
-        });
-        test('when `options` has changed, it should not trigger update', () => {
-            const onUpdate = jest.fn();
-            const onDeepUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                const [extraValue, setExtraValue] = useState(0);
-                const reducers = useUseCase(mathUseCase, { extraValue });
-                useUpdateEffect(() => {
-                    onUpdate();
-                }, [reducers]);
-                useDeepCompareUpdate(() => {
-                    onDeepUpdate();
-                }, [reducers]);
-                return setExtraValue;
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-            act(() => {
-                result.current(3);
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-        });
-        test('when `deps` change, it should update reducers', () => {
-            const onUpdate = jest.fn();
-            const onDeepUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                const [extraValue, setExtraValue] = useState(0);
-                const reducers = useUseCase(mathUseCase, { extraValue }, [extraValue]);
-                useUpdateEffect(() => {
-                    onUpdate();
-                }, [reducers]);
-                useDeepCompareUpdate(() => {
-                    onDeepUpdate();
-                }, [reducers]);
-                return setExtraValue;
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-            act(() => {
-                result.current(3);
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(1);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(1);
-        });
-        test('empty `deps` should not update reducers', () => {
-            const onUpdate = jest.fn();
-            const onDeepUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                const [extraValue, setExtraValue] = useState(0);
-                const reducers = useUseCase(mathUseCase, { extraValue }, []);
-                useUpdateEffect(() => {
-                    onUpdate();
-                }, [reducers]);
-                useDeepCompareUpdate(() => {
-                    onDeepUpdate();
-                }, [reducers]);
-                return setExtraValue;
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-            act(() => {
-                result.current(3);
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-        });
-        test('should not trigger update', () => {
-            const onUpdate = jest.fn();
-            render(_jsx(MathParent, { onUpdate: onUpdate }));
-            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
-            expect(onUpdate).toHaveBeenCalledTimes(0);
+        test('`options.watch` 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, {
+                    watch: {
+                        ext: onChangeA,
+                    },
+                });
+                return _jsx(Fragment, { children: children });
+            };
+            const B = () => {
+                useUseCase(fileUseCase, {
+                    watch: {
+                        ext: onChangeB,
+                    },
+                });
+                return _jsx(Fragment, {});
+            };
+            const C = () => {
+                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
+                    watch: {
+                        ext: onChangeC,
+                    },
+                });
+                const onFirstClick = () => {
+                    setPath(PATH_1);
+                };
+                return (_jsxs(Provider, { children: [_jsx(A, { children: _jsx(B, {}) }), _jsx("button", { onClick: onFirstClick, children: buttonText })] }));
+            };
+            render(_jsx(C, {}));
+            expect(changeTimes).toBe(0);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(onChangeA).toHaveReturnedWith(2);
+            expect(onChangeB).toHaveReturnedWith(1);
+            expect(onChangeC).toHaveReturnedWith(3);
         });
     });
 });

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

@@ -1,5 +1,7 @@
+import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
 import { EntityReducers, EntityUseCase, Reducers, UseCase } from '@mic-rexjs/usecases';
-import { UseCaseContext, UseCaseContextWithProvider } from '../../configs/usecaseContextMap/types';
+import { UseCaseProvider } from '../useProvider/types';
+export type CoreCollection<T, TEntityReducers extends EntityReducers<T>, TProvide extends UseCaseProvider | null = UseCaseProvider> = [entity: T, reducers: ContextualEntityReducers<T, TEntityReducers>, Provider: TProvide];
 export interface EntityGetter<T> {
     (): T;
 }
@@ -13,13 +15,13 @@ export interface UseCaseHookContextualOptions<T> {
     watch?: EntityWatchMap<T>;
     onChange?(newEntity: T, prevEntity: T): void;
 }
-export interface UseCaseHookOwnOptions<T, TOptions extends object> extends UseCaseHookContextualOptions<T> {
+export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extends UseCaseHookContextualOptions<T> {
     stateless?: boolean;
-    options?: TOptions;
+    options?: TUseCaseOptions;
 }
-export type UseCaseHookOptions<T, TOptions extends object> = TOptions & UseCaseHookOwnOptions<T, TOptions>;
+export type UseCaseHookOptions<T, TUseCaseOptions extends object = object> = TUseCaseOptions & UseCaseHookOwnOptions<T, TUseCaseOptions>;
 export interface UseCaseHook {
-    <T, TReducers extends EntityReducers<T>, TOptions extends UseCaseHookContextualOptions<T> = UseCaseHookContextualOptions<T>>(usecase: EntityUseCase<T, TReducers & EntityReducers<T>>, options?: TOptions): UseCaseContext<T, TReducers>;
-    <T, TReducers extends EntityReducers<T>, TUseCaseOptions extends object = object, TOptions extends UseCaseHookOptions<T, TUseCaseOptions> = UseCaseHookOptions<T, TUseCaseOptions>>(defaultEntity: T | EntityGetter<T>, usecase: EntityUseCase<T, TReducers, TUseCaseOptions> & UseCase<TReducers, TUseCaseOptions>, options?: TOptions, deps?: unknown[]): UseCaseContextWithProvider<T, TReducers>;
-    <T extends Reducers, TOptions extends object = object>(usecase: UseCase<T, TOptions>, options?: TOptions, deps?: unknown[]): T;
+    <T, TEntityReducers extends EntityReducers<T>>(usecase: EntityUseCase<T, TEntityReducers & EntityReducers<T>> & UseCase<TEntityReducers>, options?: UseCaseHookContextualOptions<T>): CoreCollection<T, TEntityReducers, null>;
+    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(initailEntity: T | EntityGetter<T>, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & UseCase<TEntityReducers, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): CoreCollection<T, TEntityReducers>;
+    <T extends Reducers, TUseCaseOptions extends object = object>(usecase: UseCase<T, TUseCaseOptions>, options?: TUseCaseOptions, deps?: unknown[]): T;
 }

package/es/hooks/useUseCaseContext/index.d.ts

@@ -0,0 +1,3 @@
+import { EntityReducers, EntityUseCase } from '@mic-rexjs/usecases';
+import { UseCaseMappingContext } from '../../configs/usecaseContextMap/types';
+export declare const useUseCaseContext: <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object, TContext extends UseCaseMappingContext<T, TEntityReducers, TUseCaseOptions> = UseCaseMappingContext<T, TEntityReducers, TUseCaseOptions>>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>, defaultContext?: TContext | null | undefined) => TContext;

package/es/hooks/useUseCaseContext/index.js

@@ -0,0 +1,17 @@
+import { useConstant } from '../useConstant';
+import { usecaseContextMap } from '../../configs/usecaseContextMap';
+import { createContext } from 'react';
+export const useUseCaseContext = (usecase, defaultContext) => {
+    return useConstant(() => {
+        const map = usecaseContextMap;
+        if (map.has(usecase)) {
+            return map.get(usecase);
+        }
+        if (defaultContext) {
+            return defaultContext;
+        }
+        const ctx = createContext({});
+        map.set(usecase, ctx);
+        return ctx;
+    });
+};

package/es/index.d.ts

@@ -1,5 +1,6 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
-export type { UseCaseFragmentProps } from './components/UseCaseFragment/types';
-export type { UseCaseContext, UseCaseContextWithProvider, UseCaseProvider } from './configs/usecaseContextMap/types';
+export type { CoreCollection } from './hooks/useUseCase/types';
 export type { UseCaseHookOptions } from './hooks/useUseCase/types';
+export type { UseCaseProvider } from './hooks/useProvider/types';
+export type { UseCaseFragmentProps } from './components/UseCaseFragment/types';

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

@@ -0,0 +1,2 @@
+import { EntityGetter } from '../../hooks/useUseCase/types';
+export declare const getRootEntity: <T>(entityState: T, entityArg: T | EntityGetter<T>, stateless?: boolean) => T;

package/es/methods/getRootEntity/index.js

@@ -0,0 +1,9 @@
+export const getRootEntity = (entityState, entityArg, stateless) => {
+    if (!stateless) {
+        return entityState;
+    }
+    if (typeof entityArg === 'function') {
+        return entityArg();
+    }
+    return entityArg;
+};

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

@@ -0,0 +1,5 @@
+import { EntityReducers, EntityUseCase } from '@mic-rexjs/usecases';
+import { UseCaseHookOptions } from '../../hooks/useUseCase/types';
+import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
+import { EntityChangeEventHandler } from './types';
+export declare const initEntityReducers: <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(entity: T, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>, options: UseCaseHookOptions<T, TUseCaseOptions>, onEntityChange: EntityChangeEventHandler<T>) => ContextualEntityReducers<T, TEntityReducers>;

package/es/methods/initEntityReducers/index.js

@@ -0,0 +1,13 @@
+import { entityReducerUseCase } from '@mic-rexjs/usecases';
+export const initEntityReducers = (entity, usecase, options, onEntityChange) => {
+    const { createEntityReducers } = entityReducerUseCase();
+    const { stateless, watch, onChange, options: usecaseOptions, ...restUseCaseOptions } = options;
+    return createEntityReducers(entity, usecase, {
+        ...restUseCaseOptions,
+        ...usecaseOptions,
+        onChange: onEntityChange,
+        onGenerate(newEntity, result) {
+            return result;
+        },
+    });
+};

package/es/methods/initEntityReducers/types.d.ts

@@ -0,0 +1,3 @@
+export interface EntityChangeEventHandler<T> {
+    (newEntity: T, prevEntity: T): void;
+}

package/es/methods/initEntityReducers/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export declare const removeItem: <T>(list: T[], item: T) => void;

package/es/methods/removeItem/index.js

@@ -0,0 +1,7 @@
+export const removeItem = (list, item) => {
+    const index = list.indexOf(item);
+    if (index === -1) {
+        return;
+    }
+    list.splice(index, 1);
+};

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

@@ -0,0 +1,3 @@
+import { OptionsRefCollection } from '../../hooks/useOptionsRefCollection/types';
+import { UseCaseHookOptions } from '../../hooks/useUseCase/types';
+export declare const triggerCallbacks: <T, TUseCaseOptions extends object, TOptions extends UseCaseHookOptions<T, TUseCaseOptions> = UseCaseHookOptions<T, TUseCaseOptions>>(optionsRefCollection: OptionsRefCollection<TOptions>, newEntity: T, prevEntity: T) => void;

package/es/methods/triggerCallbacks/index.js

@@ -0,0 +1,14 @@
+import { triggerWatchers } from '../triggerWatchers';
+export const triggerCallbacks = (optionsRefCollection, newEntity, prevEntity) => {
+    for (let { length: i } = optionsRefCollection; i > 0; i--) {
+        const { current: options } = optionsRefCollection[i - 1];
+        if (!options) {
+            continue;
+        }
+        const { onChange, watch } = options;
+        if (watch) {
+            triggerWatchers(watch, newEntity, prevEntity);
+        }
+        onChange?.(newEntity, prevEntity);
+    }
+};

package/es/{hooks/useUseCase/methods → methods}/triggerWatchers/index.d.ts

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

package/lib/components/UpdateFragment/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UpdateFragment = void 0;
+var _jsxRuntime = require("react/jsx-runtime");
+var _react = require("react");
+var UpdateFragment = function UpdateFragment(_ref) {
+  var onUpdate = _ref.onUpdate;
+  (0, _react.useEffect)(function () {
+    onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate();
+  });
+  return (0, _jsxRuntime.jsx)(_react.Fragment, {});
+};
+exports.UpdateFragment = UpdateFragment;

package/lib/configs/defaultUseCaseContext/index.js

@@ -5,5 +5,5 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.defaultUseCaseContext = void 0;
 var _react = require("react");
-var defaultUseCaseContext = (0, _react.createContext)(null);
+var defaultUseCaseContext = (0, _react.createContext)({});
 exports.defaultUseCaseContext = defaultUseCaseContext;

package/lib/configs/defaultUseCaseContext/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/hooks/useCompareDeps/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCompareDeps = void 0;
+var _react = require("react");
+var _useScope = require("../useScope");
+var useCompareDeps = function useCompareDeps(deps) {
+  var updateTimesRef = (0, _react.useRef)(0);
+  var prevDepsRef = (0, _react.useRef)([]);
+  var prevDeps = prevDepsRef.current;
+  var prevLength = prevDeps.length;
+  var length = deps.length;
+  var updated = (0, _useScope.useScope)(function () {
+    if (length !== prevLength) {
+      return true;
+    }
+    for (var i = 0; i < length; i++) {
+      if (deps[i] === prevDeps[i]) {
+        continue;
+      }
+      return true;
+    }
+    return false;
+  });
+  prevDepsRef.current = deps;
+  updateTimesRef.current += updated ? 1 : 0;
+  return updateTimesRef.current;
+};
+exports.useCompareDeps = useCompareDeps;

package/lib/hooks/useConstant/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConstant = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var useConstant = function useConstant(initialValue) {
+  var _useState = (0, _react.useState)(initialValue),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 1),
+    value = _useState2[0];
+  return value;
+};
+exports.useConstant = useConstant;

package/lib/hooks/useConstant/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/hooks/useConstantFn/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConstantFn = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var useConstantFn = function useConstantFn(initialValue) {
+  var _useState = (0, _react.useState)(function () {
+      return initialValue;
+    }),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 1),
+    value = _useState2[0];
+  return value;
+};
+exports.useConstantFn = useConstantFn;

package/lib/hooks/useOptionsRefCollection/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOptionsRefCollection = void 0;
+var _ahooks = require("ahooks");
+var _removeItem = require("../../methods/removeItem");
+var useOptionsRefCollection = function useOptionsRefCollection(isRoot, contextOptionsRefCollection, options) {
+  var optionsRef = (0, _ahooks.useLatest)(options);
+  var optionsRefCollection = (0, _ahooks.useCreation)(function () {
+    if (isRoot) {
+      return [];
+    }
+    return contextOptionsRefCollection;
+  }, [contextOptionsRefCollection, isRoot]);
+  var prevOptionsRefCollection = (0, _ahooks.usePrevious)(optionsRefCollection);
+  (0, _ahooks.useCreation)(function () {
+    if (prevOptionsRefCollection) {
+      (0, _removeItem.removeItem)(prevOptionsRefCollection, optionsRef);
+    }
+    optionsRefCollection.push(optionsRef);
+  }, [optionsRef, optionsRefCollection, prevOptionsRefCollection]);
+  (0, _ahooks.useUnmount)(function () {
+    (0, _removeItem.removeItem)(optionsRefCollection, optionsRef);
+  });
+  return optionsRefCollection;
+};
+exports.useOptionsRefCollection = useOptionsRefCollection;