@mic-rexjs/usecases-react 2.0.0 → 2.1.0

package/es/hooks/useUseCase/index.js

@@ -1,88 +1,58 @@
-import { useCreation, useMemoizedFn } from 'ahooks';
-import { useContext, useState } from 'react';
+import { useCreation } from 'ahooks';
+import { useContext } from 'react';
 import { useConstant } from '../useConstant';
 import { useConstantFn } from '../useConstantFn';
 import { useProvider } from '../useProvider';
-import { useCompareDeps } from '../useCompareDeps';
 import { initEntityReducers } from '../../methods/initEntityReducers';
-import { triggerCallbacks } from '../../methods/triggerCallbacks';
-import { getRootEntity } from '../../methods/getRootEntity';
 import { useUseCaseContext } from '../useUseCaseContext';
-import { defaultUseCaseContext } from '../../configs/defaultUseCaseContext';
 import { useIsRenderingRef } from '../useIsRenderingRef';
-import { cacheReducerCalls } from '../../methods/cacheReducerCalls';
-import { UseCaseModes } from '../../enums/UseCaseModes';
-import { toMaxArguments } from '../../methods/toMaxArguments';
-import { useChangeCallbackCollection } from '../useChangeCallbackCollection';
+import { fillArguments } from '../../methods/fillArguments';
+import { useArgumentTypes } from '../useArgumentTypes';
+import { useUseCaseStatuses } from '../useUseCaseStatuses';
+import { UseCaseStatuses } from '../../enums/UseCaseStatuses';
+import { useEntity } from '../useEntity';
+import { useContextualItem } from '../useContextualItem';
+import { cacheCalls } from '../../methods/cacheCalls';
 export const useUseCase = ((...args) => {
-    const [unsafeEntity, unsafeUsecase, unsafeMode, options, deps] = toMaxArguments(args);
-    const [entityState, setEntityState] = useState(unsafeEntity);
-    const usecase = useConstantFn(unsafeUsecase);
-    const entityUseCase = usecase;
-    const mode = useConstant(unsafeMode);
-    const depsKey = useCompareDeps(deps);
+    const argumentTypes = useArgumentTypes(args);
+    const fullArguments = fillArguments(args, argumentTypes);
+    const [unsafeEntity, unsafeUsecase, unsafeMode, options, deps] = fullArguments;
+    const unkownUsecase = useConstantFn(unsafeUsecase);
+    const usecase = unkownUsecase;
+    const entityUseCase = unkownUsecase;
     const isRenderingRef = useIsRenderingRef();
-    const isContextRoot = useConstant(typeof args[1] === 'function');
-    const defaultContext = defaultUseCaseContext;
-    const context = useUseCaseContext(entityUseCase, isContextRoot ? null : defaultContext);
-    const getContextValue = useContext(context);
-    const hasContextValueGetter = getContextValue !== null;
-    const { entity: contextEntity, reducers: contextEntityReducers = null, changeCallbackCollection: contextChangeCallbackCollection = null, } = getContextValue?.() || {};
-    // 是否需要初始化根 `redurcers`
-    const isRoot = isContextRoot || !hasContextValueGetter;
-    // 是否为上下文模式
-    const isContextMode = isContextRoot || hasContextValueGetter;
-    const changeCallbackCollection = useChangeCallbackCollection(isRoot, contextChangeCallbackCollection, options);
-    const entity = useCreation(() => {
-        if (!isContextRoot) {
-            return contextEntity;
-        }
-        return getRootEntity(entityState, unsafeEntity, mode);
-    }, [isContextRoot, contextEntity, mode, entityState, unsafeEntity]);
-    const onEntityChange = useMemoizedFn((newEntity, oldEntity) => {
-        if ((mode & UseCaseModes.Stateless) !== UseCaseModes.Stateless) {
-            setEntityState(newEntity);
+    const mode = useConstant(unsafeMode);
+    const context = useUseCaseContext(unkownUsecase, argumentTypes, mode);
+    const contextValue = useContext(context)?.() || null;
+    const entityContextValue = contextValue;
+    const statuses = useUseCaseStatuses(argumentTypes, mode, contextValue);
+    const { reducers: contextReducers = null } = contextValue || {};
+    const { store: contextStore = null } = entityContextValue || {};
+    const [entity, store] = useEntity(statuses, unsafeEntity, contextStore, options);
+    const reducers = useContextualItem(statuses, contextReducers, () => {
+        if ((statuses & UseCaseStatuses.EntityEnabled) !== UseCaseStatuses.EntityEnabled) {
+            return usecase(options);
         }
-        triggerCallbacks(changeCallbackCollection, newEntity, oldEntity);
-    });
-    const createRootEntityReducers = useMemoizedFn(() => {
-        const initOptions = options;
-        return initEntityReducers(entity, entityUseCase, initOptions, onEntityChange);
-    });
-    const createReducers = useMemoizedFn(() => {
-        return usecase(options);
-    });
-    const rootEntityReducers = useCreation(() => {
-        void depsKey;
-        if (!isContextRoot) {
-            return null;
+        const hookOptions = options;
+        return initEntityReducers(entityUseCase, store, hookOptions);
+    }, deps);
+    const Provider = useProvider(statuses, context, store, reducers);
+    return useCreation(() => {
+        if ((statuses & UseCaseStatuses.ContextEnabled) !== UseCaseStatuses.ContextEnabled) {
+            return reducers;
         }
-        return createRootEntityReducers();
-    }, [isContextRoot, depsKey, createRootEntityReducers]);
-    const entityReducers = useCreation(() => {
-        return rootEntityReducers || contextEntityReducers || {};
-    }, [rootEntityReducers, contextEntityReducers]);
-    const reducers = useCreation(() => {
-        void depsKey;
-        if (isContextMode) {
-            return {};
+        const rootEnabled = (statuses & UseCaseStatuses.RootEnabled) === UseCaseStatuses.RootEnabled;
+        if ((statuses & UseCaseStatuses.EntityEnabled) !== UseCaseStatuses.EntityEnabled) {
+            return rootEnabled ? [reducers, Provider] : reducers;
         }
-        return createReducers();
-    }, [isContextMode, depsKey, createReducers]);
-    const Provider = useProvider(context, mode, entity, entityReducers, changeCallbackCollection);
-    const createCoreCollection = useMemoizedFn((coreEntity, coreReducers) => {
-        return [
-            coreEntity,
-            cacheReducerCalls(coreReducers, () => {
+        const cachedReducers = cacheCalls(reducers, {
+            onShouldCache() {
                 return isRenderingRef.current;
-            }),
-            isContextRoot ? Provider : null,
-        ];
-    });
-    return useCreation(() => {
-        if (isContextMode) {
-            return createCoreCollection(entity, entityReducers);
+            },
+        });
+        if (rootEnabled) {
+            return [entity, cachedReducers, Provider];
         }
-        return reducers;
-    }, [isContextMode, entity, entityReducers, reducers, createCoreCollection]);
+        return [entity, cachedReducers];
+    }, [statuses, entity, reducers, Provider, isRenderingRef]);
 });

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

@@ -86,7 +86,7 @@ const Child = ({ textPrefix = '', onUpdate, onPathChange, onUndefinedEntity }) =
     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, mode, onUpdate, onSetPath }) => {
+const Parent = ({ children, mode = UseCaseModes.Normal, onUpdate, onSetPath }) => {
     const [{ path, ext }, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, mode);
     const onClick = () => {
         setPath(onSetPath?.() || '');
@@ -1403,6 +1403,31 @@ describe('useUseCase', () => {
             expect(onChangeC).toHaveReturnedWith(3);
         });
     });
+    describe('`useUseCase` should work the same as `usePseudoCoreCollection`', () => {
+        test('the return value should be `PseudoCoreCollection`', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(mathUseCase, UseCaseModes.Global);
+            });
+            const { current } = result;
+            expect(current).toEqual([expect.any(Object), expect.any(Function)]);
+        });
+        test('the return value should be `reducers` object at child component', () => {
+            const onMountA = jest.fn();
+            const A = () => {
+                const reducers = useUseCase(mathUseCase);
+                useMount(() => {
+                    onMountA(reducers);
+                });
+                return null;
+            };
+            const B = () => {
+                const [, Provider] = useUseCase(mathUseCase, UseCaseModes.Global);
+                return (_jsx(Provider, { children: _jsx(A, {}) }));
+            };
+            render(_jsx(B, {}));
+            expect(onMountA).toHaveBeenCalledWith(expect.any(Object));
+        });
+    });
     describe('`useUseCase` should work the same as `useReducers`', () => {
         test('`entity` should equal `defaultFile`', () => {
             const { result } = renderHook(() => {

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

@@ -1,8 +1,21 @@
-import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
-import { EntityReducers, EntityUseCase, Reducers, UseCase } from '@mic-rexjs/usecases';
+import { EntityReducerMap, EntityReducers, EntityUseCase, ReducerMap, Reducers, UseCase } from '@mic-rexjs/usecases';
 import { UseCaseProvider } from '../useProvider/types';
 import { UseCaseModes } from '../../enums/UseCaseModes';
-export type CoreCollection<T, TEntityReducers extends EntityReducers<T>, TProvider extends UseCaseProvider | null = UseCaseProvider> = [entity: T, reducers: ContextualEntityReducers<T, TEntityReducers>, Provider: TProvider];
+import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
+export type RootCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = [
+    entity: T,
+    reducers: ContextualEntityReducers<T, TEntityReducers>,
+    Provider: UseCaseProvider
+];
+export type ContextualCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = [
+    entity: T,
+    reducers: ContextualEntityReducers<T, TEntityReducers>
+];
+export type CoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = RootCoreCollection<T, TEntityReducers> | ContextualCoreCollection<T, TEntityReducers>;
+export type PseudoCoreCollection<T extends ReducerMap, TProvider extends UseCaseProvider | null = UseCaseProvider> = [
+    reducers: T,
+    Provider: TProvider
+];
 export interface EntityGetter<T> {
     (): T;
 }
@@ -32,67 +45,41 @@ export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extend
     options?: TUseCaseOptions;
 }
 export type UseCaseHookOptions<T, TUseCaseOptions extends object = object> = TUseCaseOptions & UseCaseHookOwnOptions<T, TUseCaseOptions>;
-export type ContextualCoreCollectionHookParameters<T, TEntityReducers extends EntityReducers<T>> = [
-    usecase: EntityUseCase<T, TEntityReducers> & 
+export interface ContextualCoreCollectionHook {
+    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & 
     /**
      * 如果不使用 `&`，那么很多情况下 `options` 类型无法被正确推导；
      * 因为使用 `&` 是为了让该参数 `usecase` 的泛型 `T` 推导占优先级，
      * 从而保证 `options` 里的泛型 `T` 是根据 `usecase` 来推导的。
      */
-    UseCase<EntityReducers<T>>,
-    options?: UseCaseHookContextualOptions<T>
-];
-export interface ContextualCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducers<T>>(...args: ContextualCoreCollectionHookParameters<T, TEntityReducers>): CoreCollection<T, TEntityReducers, null>;
+    UseCase<EntityReducerMap<T>, TUseCaseOptions>, options?: UseCaseHookContextualOptions<T>): ContextualCoreCollection<T, TEntityReducers>;
 }
-export type RootCoreCollectionHookParameters<T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object> = [
-    entity: T | EntityGetter<T>,
-    usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & 
+export interface RootCoreCollectionHook {
+    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(entity: T | EntityGetter<T>, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & 
     /**
      * 如果不使用 `&`，那么很多情况下 `options` 类型无法被正确推导；
      * 因为使用 `&` 是为了让该参数 `usecase` 的泛型 `T` 推导占优先级，
      * 从而保证 `options` 里的泛型 `T` 是根据 `usecase` 来推导的。
      */
-    UseCase<EntityReducers<T>, TUseCaseOptions>,
-    options?: UseCaseHookOptions<T, TUseCaseOptions>,
-    deps?: unknown[]
-];
-export interface RootCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(...args: RootCoreCollectionHookParameters<T, TEntityReducers, TUseCaseOptions>): CoreCollection<T, TEntityReducers>;
+    UseCase<EntityReducerMap<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): RootCoreCollection<T, TEntityReducers>;
 }
-export type ModeCoreCollectionHookParameters<T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object> = [
-    entity: T | EntityGetter<T>,
-    usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & 
+export interface ModeCoreCollectionHook {
+    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(entity: T | EntityGetter<T>, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & 
     /**
      * 如果不使用 `&`，那么很多情况下 `options` 类型无法被正确推导；
      * 因为使用 `&` 是为了让该参数 `usecase` 的泛型 `T` 推导占优先级，
      * 从而保证 `options` 里的泛型 `T` 是根据 `usecase` 来推导的。
      */
-    UseCase<EntityReducers<T>, TUseCaseOptions>,
-    mode?: UseCaseModes,
-    options?: UseCaseHookOptions<T, TUseCaseOptions>,
-    deps?: unknown[]
-];
-export interface ModeCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(...args: ModeCoreCollectionHookParameters<T, TEntityReducers, TUseCaseOptions>): CoreCollection<T, TEntityReducers>;
+    UseCase<EntityReducerMap<T>, TUseCaseOptions>, mode: UseCaseModes, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): RootCoreCollection<T, TEntityReducers>;
 }
-export interface CoreCollectionHook extends ContextualCoreCollectionHook, RootCoreCollectionHook, ModeCoreCollectionHook {
+export interface PseudoCoreCollectionHook {
+    <T extends Reducers, TUseCaseOptions extends object = object>(usecase: UseCase<T, TUseCaseOptions>, mode: UseCaseModes, options?: TUseCaseOptions, deps?: unknown[]): PseudoCoreCollection<T>;
 }
-export type ReducersHookParameters<T extends Reducers, TUseCaseOptions extends object = object> = [
-    usecase: UseCase<T, TUseCaseOptions>,
-    options?: TUseCaseOptions,
-    deps?: unknown[]
-];
 export interface ReducersHook {
-    <T extends Reducers, TUseCaseOptions extends object = object>(...args: ReducersHookParameters<T, TUseCaseOptions>): T;
+    <T extends Reducers, TUseCaseOptions extends object = object>(usecase: UseCase<T, TUseCaseOptions>, options?: TUseCaseOptions, deps?: unknown[]): T;
 }
-export type UseCaseHookParameters<T, TReducers extends Reducers, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object> = ContextualCoreCollectionHookParameters<T, TEntityReducers> | RootCoreCollectionHookParameters<T, TEntityReducers, TUseCaseOptions> | ModeCoreCollectionHookParameters<T, TEntityReducers, TUseCaseOptions> | ReducersHookParameters<TReducers, TUseCaseOptions>;
-export type UseCaseHookMaxParameters<T, TReducers extends Reducers, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object> = [
-    entity: T | EntityGetter<T> | null,
-    usecase: UseCase<TReducers, TUseCaseOptions> | EntityUseCase<T, TEntityReducers, TUseCaseOptions>,
-    mode: UseCaseModes,
-    options: TUseCaseOptions | UseCaseHookOptions<T, TUseCaseOptions> | UseCaseHookContextualOptions<T>,
-    deps: unknown[]
-];
-export interface UseCaseHook extends CoreCollectionHook, ReducersHook {
+export interface CoreCollectionHook extends ContextualCoreCollectionHook, RootCoreCollectionHook, ModeCoreCollectionHook {
+}
+export type UseCaseHookParameters = Parameters<ContextualCoreCollectionHook> | Parameters<RootCoreCollectionHook> | Parameters<ModeCoreCollectionHook> | Parameters<PseudoCoreCollectionHook> | Parameters<ReducersHook>;
+export interface UseCaseHook extends CoreCollectionHook, PseudoCoreCollectionHook, ReducersHook {
 }

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

@@ -1,3 +1,5 @@
-import { EntityReducers, EntityUseCase } from '@mic-rexjs/usecases';
-import { UseCaseContext } from '../../configs/defaultUseCaseContext/types';
-export declare const useUseCaseContext: <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object, TContext extends UseCaseContext<T, TEntityReducers> = UseCaseContext<T, TEntityReducers>>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>, defaultContext?: TContext | null | undefined) => TContext;
+import { ReducerMap, UseCase } from '@mic-rexjs/usecases';
+import { UseCaseContext, UseCaseContextValue } from '../../configs/defaultUseCaseContext/types';
+import { UseCaseArgumentTypes } from '../../enums/UseCaseArgumentTypes';
+import { UseCaseModes } from '../../enums/UseCaseModes';
+export declare const useUseCaseContext: <T extends ReducerMap<import("@mic-rexjs/usecases").Reducer<unknown>>, TUseCaseOptions extends object, TContext extends UseCaseContext<UseCaseContextValue<T>>>(usecase: UseCase<T, TUseCaseOptions>, argumentTypes?: UseCaseArgumentTypes, mode?: UseCaseModes) => TContext;

package/es/hooks/useUseCaseContext/index.js

@@ -1,17 +1,53 @@
 import { useConstant } from '../useConstant';
-import { usecaseContextMap } from '../../configs/usecaseContextMap';
+import { usecaseContextReferenceMap } from '../../configs/useCaseContextReferenceMap';
 import { createContext } from 'react';
-export const useUseCaseContext = (usecase, defaultContext) => {
-    return useConstant(() => {
-        const map = usecaseContextMap;
+import { useUnmount } from 'ahooks';
+import { UseCaseArgumentTypes } from '../../enums/UseCaseArgumentTypes';
+import { UseCaseModes } from '../../enums/UseCaseModes';
+import { defaultUseCaseContext } from '../../configs/defaultUseCaseContext';
+export const useUseCaseContext = (usecase, argumentTypes = UseCaseArgumentTypes.None, mode = UseCaseModes.Normal) => {
+    const map = usecaseContextReferenceMap;
+    const context = useConstant(() => {
         if (map.has(usecase)) {
-            return map.get(usecase);
+            const reference = map.get(usecase);
+            const { value, times } = reference;
+            map.set(usecase, {
+                value,
+                times: times + 1,
+            });
+            return value;
         }
-        if (defaultContext) {
-            return defaultContext;
+        switch (true) {
+            case (mode & UseCaseModes.Global) === UseCaseModes.Global:
+            case (argumentTypes & UseCaseArgumentTypes.Entity) === UseCaseArgumentTypes.Entity:
+                break;
+            default:
+                return defaultUseCaseContext;
         }
         const ctx = createContext(null);
-        map.set(usecase, ctx);
+        map.set(usecase, {
+            value: ctx,
+            times: 1,
+        });
         return ctx;
     });
+    useUnmount(() => {
+        if (!map.has(usecase)) {
+            return;
+        }
+        const reference = map.get(usecase);
+        const { value, times } = reference;
+        if (context !== value) {
+            return;
+        }
+        if (times === 1) {
+            map.delete(usecase);
+            return;
+        }
+        map.set(usecase, {
+            value,
+            times: times - 1,
+        });
+    });
+    return context;
 };

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

@@ -0,0 +1,87 @@
+import { describe, expect, test } from '@jest/globals';
+import { renderHook } from '@testing-library/react';
+import { useUseCaseContext } from '.';
+import { defaultUseCaseContext } from '../../configs/defaultUseCaseContext';
+import { usecaseContextReferenceMap } from '../../configs/useCaseContextReferenceMap';
+import { UseCaseModes } from '../../enums/UseCaseModes';
+import { UseCaseArgumentTypes } from '../../enums/UseCaseArgumentTypes';
+const testUseCase = () => {
+    return {};
+};
+describe('useUseCaseContext', () => {
+    test('should return the default context if map has not saved a usecase with default args', () => {
+        const { result } = renderHook(() => {
+            return useUseCaseContext(testUseCase);
+        });
+        const { current } = result;
+        expect(current).toBe(defaultUseCaseContext);
+    });
+    test('should return the default context if map has not saved a usecase with `UseCaseArgumentTypes.None` & `UseCaseModes.Normal`', () => {
+        const { result } = renderHook(() => {
+            return useUseCaseContext(testUseCase, UseCaseArgumentTypes.None, UseCaseModes.Normal);
+        });
+        const { current } = result;
+        expect(current).toBe(defaultUseCaseContext);
+    });
+    test('should return a new context if map has not saved a usecase with `UseCaseArgumentTypes.Entity` & `UseCaseModes.Normal`', () => {
+        const { result } = renderHook(() => {
+            return useUseCaseContext(testUseCase, UseCaseArgumentTypes.Entity, UseCaseModes.Normal);
+        });
+        const { current } = result;
+        expect(typeof current).toBe('object');
+    });
+    test('should return a new context if map has not saved a usecase with `UseCaseArgumentTypes.None` & `UseCaseModes.Global`', () => {
+        const { result } = renderHook(() => {
+            return useUseCaseContext(testUseCase, UseCaseArgumentTypes.None, UseCaseModes.Global);
+        });
+        const { current } = result;
+        expect(typeof current).toBe('object');
+    });
+    test.each([
+        {
+            type: UseCaseArgumentTypes.Entity,
+            mode: UseCaseModes.Normal,
+        },
+        {
+            type: UseCaseArgumentTypes.None,
+            mode: UseCaseModes.Global,
+        },
+        {
+            type: UseCaseArgumentTypes.Entity,
+            mode: UseCaseModes.Global,
+        },
+    ])('should return the existing context if map has save a usecase already', ({ type, mode }) => {
+        const { result } = renderHook(() => {
+            return useUseCaseContext(testUseCase, type, mode) === useUseCaseContext(testUseCase);
+        });
+        const { current: isSame } = result;
+        expect(isSame).toBe(true);
+    });
+    test('check context reference times when mount/unmount a usecase', () => {
+        const { unmount: unmount1 } = renderHook(() => {
+            useUseCaseContext(testUseCase, UseCaseArgumentTypes.Entity);
+        });
+        const { times: times1 } = usecaseContextReferenceMap.get(testUseCase);
+        const { unmount: unmount2 } = renderHook(() => {
+            useUseCaseContext(testUseCase);
+            useUseCaseContext(testUseCase);
+        });
+        const { times: times2 } = usecaseContextReferenceMap.get(testUseCase);
+        expect(times1).toBe(1);
+        expect(times2).toBe(3);
+        unmount1();
+        const { times: times3 } = usecaseContextReferenceMap.get(testUseCase);
+        expect(times3).toBe(2);
+        unmount2();
+        const hasSaved = usecaseContextReferenceMap.has(testUseCase);
+        expect(hasSaved).toBe(false);
+    });
+    test('context reference times should not change when rerender hooks', () => {
+        const { rerender } = renderHook(() => {
+            useUseCaseContext(testUseCase, UseCaseArgumentTypes.Entity);
+        });
+        rerender();
+        const { times } = usecaseContextReferenceMap.get(testUseCase);
+        expect(times).toBe(1);
+    });
+});

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

@@ -0,0 +1,6 @@
+import { UseCaseContextValue } from '../../configs/defaultUseCaseContext/types';
+import { UseCaseArgumentTypes } from '../../enums/UseCaseArgumentTypes';
+import { UseCaseModes } from '../../enums/UseCaseModes';
+import { UseCaseStatuses } from '../../enums/UseCaseStatuses';
+import { ReducerMap } from '@mic-rexjs/usecases';
+export declare const useUseCaseStatuses: <T, TReducers extends ReducerMap<import("@mic-rexjs/usecases").Reducer<unknown>>>(argumentTypes: UseCaseArgumentTypes, mode: UseCaseModes, contextValue: UseCaseContextValue<TReducers> | null) => UseCaseStatuses;

package/es/hooks/useUseCaseStatuses/index.js

@@ -0,0 +1,29 @@
+import { UseCaseArgumentTypes } from '../../enums/UseCaseArgumentTypes';
+import { UseCaseModes } from '../../enums/UseCaseModes';
+import { UseCaseStatuses } from '../../enums/UseCaseStatuses';
+import { useCreation } from 'ahooks';
+export const useUseCaseStatuses = (argumentTypes, mode, contextValue) => {
+    return useCreation(() => {
+        let statuses = UseCaseStatuses.None;
+        const { store } = (contextValue || {});
+        if ((argumentTypes & UseCaseArgumentTypes.Entity) === UseCaseArgumentTypes.Entity) {
+            statuses |= UseCaseStatuses.EntityRootEnabled;
+        }
+        if (contextValue === null) {
+            statuses |= UseCaseStatuses.RootEnabled;
+        }
+        else {
+            statuses |= UseCaseStatuses.ContextEnabled;
+        }
+        if (store) {
+            statuses |= UseCaseStatuses.EntityEnabled;
+        }
+        if ((mode & UseCaseModes.Stateless) === UseCaseModes.Stateless) {
+            statuses |= UseCaseStatuses.StatelessEnabled;
+        }
+        if ((mode & UseCaseModes.Global) === UseCaseModes.Global) {
+            statuses |= UseCaseStatuses.GlobalEnabled;
+        }
+        return statuses;
+    }, [argumentTypes, contextValue, mode]);
+};

package/es/index.d.ts

@@ -2,7 +2,7 @@ export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
 export { useGlobalUseCase } from './hooks/useGlobalUseCase';
 export { useStatelessUseCase } from './hooks/useStatelessUseCase';
-export type { CoreCollection } from './hooks/useUseCase/types';
+export type { RootCoreCollection, ContextualCoreCollection, CoreCollection, PseudoCoreCollection, } 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/cacheCall/index.d.ts

@@ -0,0 +1,2 @@
+import { CacheableFactory, CacheCallOptions } from './types';
+export declare const cacheCall: <T extends CacheableFactory>(factory: T, options?: CacheCallOptions) => T;

package/es/methods/cacheCall/index.js

@@ -0,0 +1,26 @@
+import { isSameArray } from '../isSameArray';
+export const cacheCall = (factory, options) => {
+    let cache;
+    const { onShouldCache = () => {
+        return true;
+    }, onCompare = (newArgs, oldArgs) => {
+        return isSameArray(newArgs, oldArgs);
+    }, } = options || {};
+    return ((...args) => {
+        const cacheable = onShouldCache();
+        if (cache && cacheable) {
+            const { parameters, returnValue } = cache;
+            if (onCompare(parameters, args)) {
+                return returnValue;
+            }
+        }
+        const returnValue = factory(...args);
+        if (cacheable) {
+            cache = {
+                parameters: args,
+                returnValue,
+            };
+        }
+        return returnValue;
+    });
+};

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

@@ -0,0 +1,13 @@
+import { Reducer } from '@mic-rexjs/usecases';
+import { RestArguments } from '@mic-rexjs/usecases/es/types';
+export interface CacheableFactory {
+    (...args: RestArguments): unknown;
+}
+export interface CacheCallOptions {
+    onShouldCache?(): boolean;
+    onCompare?(newArgs: RestArguments, oldArgs: RestArguments): boolean;
+}
+export interface CallCache<T extends Reducer> {
+    parameters: Parameters<T>;
+    returnValue: ReturnType<T>;
+}

package/es/methods/cacheCall/types.js

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

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

@@ -0,0 +1,2 @@
+import { CacheCallOptions, CacheableFactory } from '../cacheCall/types';
+export declare const cacheCalls: <T extends Record<string, CacheableFactory>>(sourceFactories: T, options?: CacheCallOptions) => T;

package/es/methods/cacheCalls/index.js

@@ -0,0 +1,8 @@
+import { cacheCall } from '../cacheCall';
+export const cacheCalls = (sourceFactories, options) => {
+    const cachedFactories = {};
+    Object.entries(sourceFactories).forEach(([key, factory]) => {
+        cachedFactories[key] = cacheCall(factory, options);
+    });
+    return cachedFactories;
+};

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

@@ -0,0 +1,5 @@
+import { UseCaseHookParameters } from '../../hooks/useUseCase/types';
+import { ReducerMap } from '@mic-rexjs/usecases';
+import { UseCaseHookFullParameters } from './types';
+import { UseCaseArgumentTypes } from '../../enums/UseCaseArgumentTypes';
+export declare const fillArguments: <T, TReducers extends ReducerMap<import("@mic-rexjs/usecases").Reducer<unknown>>, TUseCaseOptions extends object>(args: UseCaseHookParameters, argumentTypes: UseCaseArgumentTypes) => UseCaseHookFullParameters<T, TReducers, TUseCaseOptions>;

package/es/methods/fillArguments/index.js

@@ -0,0 +1,41 @@
+import { UseCaseModes } from '../../enums/UseCaseModes';
+import { UseCaseArgumentTypes } from '../../enums/UseCaseArgumentTypes';
+export const fillArguments = (args, argumentTypes) => {
+    const [arg1, arg2, arg3, arg4, arg5] = args;
+    const hasEntity = (argumentTypes & UseCaseArgumentTypes.Entity) === UseCaseArgumentTypes.Entity;
+    const hasMode = (argumentTypes & UseCaseArgumentTypes.Mode) === UseCaseArgumentTypes.Mode;
+    if (hasEntity) {
+        if (hasMode) {
+            return [
+                arg1,
+                arg2,
+                arg3,
+                (arg4 || {}),
+                arg5 || [],
+            ];
+        }
+        return [
+            arg1,
+            arg2,
+            UseCaseModes.Normal,
+            (arg3 || {}),
+            (arg4 || []),
+        ];
+    }
+    if (hasMode) {
+        return [
+            null,
+            arg1,
+            arg2,
+            (arg3 || {}),
+            (arg4 || []),
+        ];
+    }
+    return [
+        null,
+        arg1,
+        UseCaseModes.Normal,
+        (arg2 || {}),
+        (arg3 || []),
+    ];
+};

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

@@ -0,0 +1,10 @@
+import { UseCaseModes } from '../../enums/UseCaseModes';
+import { EntityGetter, UseCaseHookContextualOptions, UseCaseHookOptions } from '../../hooks/useUseCase/types';
+import { EntityReducerMap, EntityUseCase, ReducerMap, UseCase } from '@mic-rexjs/usecases';
+export type UseCaseHookFullParameters<T, TReducers extends ReducerMap, TUseCaseOptions extends object> = [
+    entity: T | EntityGetter<T>,
+    usecase: UseCase<TReducers, TUseCaseOptions> | EntityUseCase<T, TReducers & EntityReducerMap<T>, TUseCaseOptions>,
+    mode: UseCaseModes,
+    options: TUseCaseOptions | UseCaseHookOptions<T, TUseCaseOptions> | UseCaseHookContextualOptions<T>,
+    deps: unknown[]
+];

package/es/methods/fillArguments/types.js

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

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

@@ -0,0 +1,3 @@
+import { UseCaseStatuses } from '../../enums/UseCaseStatuses';
+import { EntityGetter } from '../../hooks/useUseCase/types';
+export declare const getRenderingEntity: <T>(statuses: UseCaseStatuses, entityState: T, rootEntity: T | EntityGetter<T>, contextEntity: T) => T;