@mic-rexjs/usecases-react 2.6.3 → 2.7.0

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

@@ -5,6 +5,7 @@ import { renderHook, act, render, fireEvent, screen } from '@testing-library/rea
 import { useUseCase } from '.';
 import { useDeepCompareEffect, useMemoizedFn, useMount, useUpdate, useUpdateEffect } from 'ahooks';
 import { Fragment, useEffect, useRef, useState } from 'react';
+import { registerGlobalUseCase } from '../../methods/registerGlobalUseCase';
 const EXT_1 = '.png';
 const EXT_2 = '.jpg';
 const PATH_1 = `hello${EXT_1}`;
@@ -1104,7 +1105,7 @@ describe('useUseCase', () => {
             expect(onBooleanMount).toHaveBeenCalledWith(true);
         });
     });
-    describe('`useUseCase` should work the same as useContextualCoreCollection', () => {
+    describe('`useUseCase` should work the same as `useContextualCoreCollection`', () => {
         test('Should trigger Parent & Child to update', () => {
             const onParentUpdate = jest.fn();
             const onChildUpdate = jest.fn();
@@ -1433,6 +1434,110 @@ describe('useUseCase', () => {
                 oldValue: EXT_1,
             });
         });
+        test('global usecase should share the entity to any components', () => {
+            const onValue = jest.fn();
+            const firstButtonText = 'first button';
+            const secondButtonText = 'second button';
+            const numberUseCase = () => {
+                return entityUseCase();
+            };
+            const A = () => {
+                const [entity, { setEntity }] = useUseCase(numberUseCase);
+                const onButtonClick = () => {
+                    setEntity(2);
+                };
+                useMount(() => {
+                    onValue(entity);
+                });
+                return (_jsx("div", { children: _jsx("button", { onClick: onButtonClick, children: firstButtonText }) }));
+            };
+            const B = () => {
+                const [entity, { setEntity }] = useUseCase(numberUseCase);
+                const onButtonClick = () => {
+                    setEntity(3);
+                };
+                useMount(() => {
+                    onValue(entity);
+                });
+                return (_jsx("div", { children: _jsx("button", { onClick: onButtonClick, children: secondButtonText }) }));
+            };
+            registerGlobalUseCase(1, numberUseCase);
+            render(_jsx(A, {}));
+            expect(onValue).toHaveBeenNthCalledWith(1, 1);
+            fireEvent.click(screen.getByText(firstButtonText));
+            render(_jsx(B, {}));
+            expect(onValue).toHaveBeenNthCalledWith(2, 2);
+            fireEvent.click(screen.getByText(secondButtonText));
+        });
+        test('global usecase should trigger `onChange` in any components when entity has changed', () => {
+            const onValueChange1 = jest.fn();
+            const onValueChange2 = jest.fn();
+            const firstButtonText = 'first button';
+            const secondButtonText = 'second button';
+            const numberUseCase = () => {
+                return entityUseCase();
+            };
+            const A = () => {
+                const [, { setEntity }] = useUseCase(numberUseCase, {
+                    onChange(value) {
+                        onValueChange1(value);
+                    },
+                });
+                const onButtonClick = () => {
+                    setEntity(2);
+                };
+                return (_jsx("div", { children: _jsx("button", { onClick: onButtonClick, children: firstButtonText }) }));
+            };
+            const B = () => {
+                const [, { setEntity }] = useUseCase(numberUseCase, {
+                    onChange(value) {
+                        onValueChange2(value);
+                    },
+                });
+                const onButtonClick = () => {
+                    setEntity(3);
+                };
+                return (_jsx("div", { children: _jsx("button", { onClick: onButtonClick, children: secondButtonText }) }));
+            };
+            registerGlobalUseCase(1, numberUseCase);
+            render(_jsx(A, {}));
+            fireEvent.click(screen.getByText(firstButtonText));
+            expect(onValueChange1).toHaveBeenNthCalledWith(1, 2);
+            render(_jsx(B, {}));
+            fireEvent.click(screen.getByText(secondButtonText));
+            expect(onValueChange1).toHaveBeenNthCalledWith(2, 3);
+            expect(onValueChange2).toHaveBeenNthCalledWith(1, 3);
+        });
+        test('global usecase should trigger update for components when entity has changed', () => {
+            const onUpdate1 = jest.fn();
+            const onUpdate2 = jest.fn();
+            const buttonText = 'my button';
+            const numberUseCase = () => {
+                return entityUseCase();
+            };
+            const A = () => {
+                const [entity, { setEntity }] = useUseCase(numberUseCase);
+                const onButtonClick = () => {
+                    setEntity(6);
+                };
+                useUpdateEffect(() => {
+                    onUpdate1(entity);
+                }, [entity]);
+                return (_jsx("div", { children: _jsx("button", { onClick: onButtonClick, children: buttonText }) }));
+            };
+            const B = () => {
+                const [entity] = useUseCase(numberUseCase);
+                useUpdateEffect(() => {
+                    onUpdate2(entity);
+                }, [entity]);
+                return _jsx(A, {});
+            };
+            registerGlobalUseCase(1, numberUseCase);
+            render(_jsx(B, {}));
+            fireEvent.click(screen.getByText(buttonText));
+            expect(onUpdate1).toHaveBeenNthCalledWith(1, 6);
+            expect(onUpdate2).toHaveBeenNthCalledWith(1, 6);
+        });
     });
     describe('`useUseCase` should work the same as `useReducers`', () => {
         test('`entity` should equal `defaultFile`', () => {

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

@@ -1,20 +1,20 @@
-import { EntityReducers, EntityUseCase, Reducers, UseCase } from '@mic-rexjs/usecases';
+import { UseCase } from '@mic-rexjs/usecases';
 import { UseCaseProvider } from '../useProvider/types';
-import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
-import { SymbolSet, SymbolSetTarget } from '@mic-rexjs/usecases/es/types';
+import { ContextualEntityReducers } from '../../usecases/contextUseCase/types';
+import { EntityReducerMap, EntityReducers, InferableEntityUseCase, ReducerMap, SymbolSet, SymbolSetTarget } from '@mic-rexjs/usecases/es/types';
 export interface NonEntitySymbolSet extends SymbolSet {
     entity?: never;
 }
-export type RootCoreCollection<T, TEntityReducers extends EntityReducers<T>> = [
+export type RootCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = [
     entity: T,
     reducers: ContextualEntityReducers<T, TEntityReducers>,
     Provider: UseCaseProvider
 ];
-export type ContextualCoreCollection<T, TEntityReducers extends EntityReducers<T>> = [
+export type ContextualCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = [
     entity: T,
     reducers: ContextualEntityReducers<T, TEntityReducers>
 ];
-export type CoreCollection<T, TEntityReducers extends EntityReducers<T>> = RootCoreCollection<T, TEntityReducers> | ContextualCoreCollection<T, TEntityReducers>;
+export type CoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = RootCoreCollection<T, TEntityReducers> | ContextualCoreCollection<T, TEntityReducers>;
 export interface EntityGetter<T> {
     (): T;
 }
@@ -47,13 +47,13 @@ export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extend
 }
 export type UseCaseHookOptions<T, TUseCaseOptions extends object = object> = TUseCaseOptions & UseCaseHookOwnOptions<T, TUseCaseOptions>;
 export interface ReducersHook {
-    <T extends Reducers, TUseCaseOptions extends object = object>(usecase: UseCase<T & SymbolSetTarget<NonEntitySymbolSet>, TUseCaseOptions>, options?: TUseCaseOptions, deps?: unknown[]): T;
+    <T extends ReducerMap, TUseCaseOptions extends object = object>(usecase: UseCase<T & SymbolSetTarget<NonEntitySymbolSet>, TUseCaseOptions>, options?: TUseCaseOptions, deps?: unknown[]): T;
 }
 export interface ContextualCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducers<T>>(usecase: EntityUseCase<T, TEntityReducers> & UseCase<EntityReducers<T>>, options?: UseCaseHookContextualOptions<T>, deps?: unknown[]): ContextualCoreCollection<T, TEntityReducers>;
+    <T, TEntityReducers extends EntityReducers<T>>(usecase: InferableEntityUseCase<T, TEntityReducers>, options?: UseCaseHookContextualOptions<T>, deps?: unknown[]): ContextualCoreCollection<T, TEntityReducers>;
 }
 export interface RootCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(entity: T | EntityGetter<T>, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & UseCase<EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): RootCoreCollection<T, TEntityReducers>;
+    <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object>(entity: T | EntityGetter<T>, usecase: InferableEntityUseCase<T, TEntityReducers & EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): RootCoreCollection<T, EntityReducers<T, TEntityReducers>>;
 }
 export interface CoreCollectionHook extends ContextualCoreCollectionHook, RootCoreCollectionHook {
 }

package/es/index.d.ts

@@ -1,5 +1,6 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
+export { registerGlobalUseCase } from './methods/registerGlobalUseCase';
 export type { EntityWatchEvent, RootCoreCollection, ContextualCoreCollection, CoreCollection, } from './hooks/useUseCase/types';
 export type { UseCaseHookOptions } from './hooks/useUseCase/types';
 export type { UseCaseProvider } from './hooks/useProvider/types';

package/es/index.js

@@ -1,2 +1,3 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
+export { registerGlobalUseCase } from './methods/registerGlobalUseCase';

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

@@ -1,4 +1,5 @@
-import { EntityReducers, EntityStore, EntityUseCase } from '@mic-rexjs/usecases';
+import { EntityStore } from '@mic-rexjs/usecases';
 import { UseCaseHookOptions } from '../../hooks/useUseCase/types';
-import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
-export declare const initEntityReducers: <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>, store: EntityStore<T>, options: UseCaseHookOptions<T, TUseCaseOptions>) => ContextualEntityReducers<T, TEntityReducers>;
+import { ContextualEntityReducers } from '../../usecases/contextUseCase/types';
+import { EntityReducerMap, InferableEntityUseCase } from '@mic-rexjs/usecases/es/types';
+export declare const initEntityReducers: <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object>(usecase: InferableEntityUseCase<T, TEntityReducers, TUseCaseOptions>, store: EntityStore<T>, options: UseCaseHookOptions<T, TUseCaseOptions>) => ContextualEntityReducers<T, TEntityReducers>;

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

@@ -0,0 +1 @@
+export declare const registerGlobalUseCase: <T>(entity: T, usecase: import("@mic-rexjs/usecases/es/types").InferableEntityUseCase<T>) => void;

package/es/methods/registerGlobalUseCase/index.js

@@ -0,0 +1,2 @@
+import { contextUseCase } from '../../usecases/contextUseCase';
+export const { registerGlobalUseCase } = contextUseCase();

package/es/usecases/contextUseCase/index.d.ts

@@ -1,2 +1,2 @@
-import { ContextReducers } from './types';
-export declare const contextUseCase: () => ContextReducers;
+import { ContextUseCase } from './types';
+export declare const contextUseCase: ContextUseCase;

package/es/usecases/contextUseCase/index.js

@@ -1,19 +1,100 @@
-export const contextUseCase = () => {
-    const hasContext = (target) => {
-        if (typeof target !== 'object') {
-            return false;
-        }
-        if (!Array.isArray(target)) {
-            return false;
-        }
-        const { length } = target;
-        const reducers = target[1];
-        if (length < 2) {
-            return false;
-        }
-        return typeof reducers === 'object';
+import { createUseCase, EntityStore } from '@mic-rexjs/usecases';
+import { ArgumentTypes } from '../../enums/ArgumentTypes';
+import { createContext } from 'react';
+import { Statuses } from '../../enums/Statuses';
+import { initEntityReducers } from '../../methods/initEntityReducers';
+export const contextUseCase = createUseCase(() => {
+    const referenceMap = new Map();
+    const globalContextMap = new Map();
+    const globalContextValueMap = new Map();
+    const defaultUseCaseContext = createContext(null);
+    return () => {
+        const createContextValue = (store, reducers, statuses) => {
+            if ((statuses & Statuses.EntityEnabled) === Statuses.EntityEnabled) {
+                return {
+                    store,
+                    reducers,
+                    statuses,
+                };
+            }
+            return { reducers, statuses };
+        };
+        const getGlobalContextValue = (key) => {
+            const context = typeof key === 'function' ? globalContextMap.get(key) : key;
+            return globalContextValueMap.get(context) || null;
+        };
+        const isGlobal = (usecase) => {
+            return globalContextMap.has(usecase);
+        };
+        const registerUseCase = (usecase, argumentTypes) => {
+            if (referenceMap.has(usecase)) {
+                const reference = referenceMap.get(usecase);
+                const { value, times } = reference;
+                referenceMap.set(usecase, {
+                    value,
+                    times: times + 1,
+                });
+                return value;
+            }
+            if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
+                return defaultUseCaseContext;
+            }
+            const context = createContext(null);
+            referenceMap.set(usecase, {
+                value: context,
+                times: 1,
+            });
+            return context;
+        };
+        const unregisterUseCase = (usecase, argumentTypes) => {
+            if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
+                return false;
+            }
+            if (!referenceMap.has(usecase)) {
+                return false;
+            }
+            const reference = referenceMap.get(usecase);
+            const { value, times } = reference;
+            if (times === 1) {
+                referenceMap.delete(usecase);
+            }
+            else {
+                referenceMap.set(usecase, {
+                    value,
+                    times: times - 1,
+                });
+            }
+            return true;
+        };
+        const registerGlobalUseCase = (entity, usecase) => {
+            if (globalContextMap.has(usecase)) {
+                return;
+            }
+            const store = new EntityStore(entity);
+            const reducers = initEntityReducers(usecase, store, {});
+            const contextValue = createContextValue(store, reducers, Statuses.GlobalEnabled);
+            const context = registerUseCase(usecase, ArgumentTypes.GlobalEntity);
+            globalContextMap.set(usecase, context);
+            globalContextValueMap.set(context, contextValue);
+        };
+        const unregisterGlobalUseCase = (usecase) => {
+            if (!globalContextMap.has(usecase)) {
+                return false;
+            }
+            const context = globalContextMap.get(usecase);
+            globalContextMap.delete(usecase);
+            globalContextValueMap.delete(context);
+            referenceMap.delete(usecase);
+            return true;
+        };
+        return {
+            createContextValue,
+            getGlobalContextValue,
+            isGlobal,
+            registerUseCase,
+            registerGlobalUseCase,
+            unregisterUseCase,
+            unregisterGlobalUseCase,
+        };
     };
-    return {
-        hasContext,
-    };
-};
+});

package/es/usecases/contextUseCase/types.d.ts

@@ -1,4 +1,35 @@
-import { Reducers } from '@mic-rexjs/usecases';
+/// <reference types="react" />
+import { ArgumentTypes } from '../../enums/ArgumentTypes';
+import { Statuses } from '../../enums/Statuses';
+import { AsyncEntityGenerator, EntityGenerator, EntityReducer, EntityStore, ReducerKeys, Reducers } from '@mic-rexjs/usecases';
+import { EntityReducerMap, InferableEntityUseCase, InferableUseCase, ReducerMap } from '@mic-rexjs/usecases/es/types';
+export type ContextualEntityReducer<T, TEntityReducer extends EntityReducer<T>> = TEntityReducer extends (entity: infer TEntity, ...args: infer TArgs) => infer TReturn ? (...args: TArgs) => TReturn extends AsyncEntityGenerator<TEntity, infer TResult> ? Promise<TResult> : TReturn extends EntityGenerator<TEntity, infer TResult> ? TResult : TReturn : never;
+export type ContextualEntityReducers<T, TEntityReducers extends EntityReducerMap<T>> = {
+    [K in ReducerKeys<TEntityReducers>]: ContextualEntityReducer<T, TEntityReducers[K]>;
+};
+export interface ContextValue<T extends ReducerMap> {
+    reducers: T;
+    statuses: Statuses;
+}
+export interface EntityContextValue<T, TEntityReducers extends EntityReducerMap<T>> extends ContextValue<ContextualEntityReducers<T, TEntityReducers>> {
+    store: EntityStore<T>;
+}
+export interface Context<T> extends React.Context<T | null> {
+}
+export interface ContextReference<T> {
+    value: Context<T>;
+    times: number;
+}
 export type ContextReducers = Reducers<{
-    hasContext<T>(target: T): boolean;
+    createContextValue<T, TReducers extends ReducerMap>(store: EntityStore<T>, reducers: TReducers, statuses: Statuses): ContextValue<TReducers>;
+    getGlobalContextValue<T, TEntityReducers extends EntityReducerMap<T>, TContextValue extends ContextValue<TEntityReducers> = ContextValue<TEntityReducers>>(key: Context<TContextValue>): TContextValue;
+    getGlobalContextValue<T, TEntityReducers extends EntityReducerMap<T>>(usecase: InferableEntityUseCase<T, TEntityReducers>): ContextValue<TEntityReducers> | null;
+    isGlobal<T>(usecase: InferableEntityUseCase<T>): boolean;
+    registerUseCase<T extends ReducerMap, TUseCaseOptions extends object, TContext extends Context<ContextValue<T>> = Context<ContextValue<T>>>(usecase: InferableUseCase<T, TUseCaseOptions>, argumentTypes: ArgumentTypes): TContext;
+    unregisterUseCase<T extends ReducerMap, TUseCaseOptions extends object>(usecase: InferableUseCase<T, TUseCaseOptions>, argumentTypes: ArgumentTypes): boolean;
+    registerGlobalUseCase<T>(entity: T, usecase: InferableEntityUseCase<T>): void;
+    unregisterGlobalUseCase<T>(usecase: InferableEntityUseCase<T>): boolean;
 }>;
+export interface ContextUseCase {
+    (): ContextReducers;
+}

package/lib/enums/ArgumentTypes/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArgumentTypes = void 0;
+var ArgumentTypes;
+(function (ArgumentTypes) {
+  ArgumentTypes[ArgumentTypes["None"] = 0] = "None";
+  ArgumentTypes[ArgumentTypes["Entity"] = 2] = "Entity";
+  ArgumentTypes[ArgumentTypes["Global"] = 4] = "Global";
+  ArgumentTypes[ArgumentTypes["GlobalEntity"] = 6] = "GlobalEntity";
+})(ArgumentTypes || (exports.ArgumentTypes = ArgumentTypes = {}));

package/lib/enums/Statuses/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Statuses = void 0;
+var Statuses;
+(function (Statuses) {
+  Statuses[Statuses["None"] = 0] = "None";
+  /**
+   * 是否需要初始化根 `redurcers`
+   */
+  Statuses[Statuses["RootEnabled"] = 2] = "RootEnabled";
+  /**
+   * 是否为上下文模式
+   */
+  Statuses[Statuses["ContextEnabled"] = 4] = "ContextEnabled";
+  /**
+   * 是否有 `entity`
+   */
+  Statuses[Statuses["EntityEnabled"] = 8] = "EntityEnabled";
+  /**
+   * 是否为全局模式
+   */
+  Statuses[Statuses["GlobalEnabled"] = 28] = "GlobalEnabled";
+  /**
+   * 是否为需要提供 `Provider` 去挂载根 `context`
+   */
+  Statuses[Statuses["ContextRootEnabled"] = 6] = "ContextRootEnabled";
+  /**
+   * 是否初始化与 `entity` 相关的 `reducers`
+   */
+  Statuses[Statuses["EntityRootEnabled"] = 14] = "EntityRootEnabled";
+})(Statuses || (exports.Statuses = Statuses = {}));

package/lib/hooks/useArgumentTypes/index.js

@@ -7,16 +7,22 @@ Object.defineProperty(exports, "__esModule", {
 exports.useArgumentTypes = void 0;
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _UseCaseArgumentTypes = require("../../enums/UseCaseArgumentTypes");
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
 var _useConstant = require("../useConstant");
+var _useContextUseCase2 = require("../useContextUseCase");
 var useArgumentTypes = exports.useArgumentTypes = function useArgumentTypes(args) {
+  var _useContextUseCase = (0, _useContextUseCase2.useContextUseCase)(),
+    isGlobal = _useContextUseCase.isGlobal;
   return (0, _useConstant.useConstant)(function () {
-    var types = _UseCaseArgumentTypes.UseCaseArgumentTypes.None;
+    var types = _ArgumentTypes.ArgumentTypes.None;
     var _args = (0, _slicedToArray2["default"])(args, 2),
+      arg1 = _args[0],
       arg2 = _args[1];
     var type2 = (0, _typeof2["default"])(arg2);
     if (type2 === 'function') {
-      types |= _UseCaseArgumentTypes.UseCaseArgumentTypes.Entity;
+      types |= _ArgumentTypes.ArgumentTypes.Entity;
+    } else if (isGlobal(arg1)) {
+      types |= _ArgumentTypes.ArgumentTypes.Global;
     }
     return types;
   });

package/lib/hooks/useContext/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useContext = void 0;
+var _useConstant = require("../useConstant");
+var _ahooks = require("ahooks");
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
+var _useContextUseCase2 = require("../useContextUseCase");
+var useContext = exports.useContext = function useContext(usecase) {
+  var argumentTypes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _ArgumentTypes.ArgumentTypes.None;
+  var _useContextUseCase = (0, _useContextUseCase2.useContextUseCase)(),
+    registerUseCase = _useContextUseCase.registerUseCase,
+    unregisterUseCase = _useContextUseCase.unregisterUseCase;
+  var context = (0, _useConstant.useConstant)(function () {
+    return registerUseCase(usecase, argumentTypes);
+  });
+  (0, _ahooks.useUnmount)(function () {
+    unregisterUseCase(usecase, argumentTypes);
+  });
+  return context;
+};

package/lib/hooks/useContext/index.test.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _globals = require("@jest/globals");
+var _react = require("@testing-library/react");
+var _ = require(".");
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
+var _react2 = require("react");
+var testUseCase = function testUseCase() {
+  return {};
+};
+(0, _globals.describe)('useContext', function () {
+  (0, _globals.test)('should return the default context with value `null` if map has not saved a usecase with default args', function () {
+    var _renderHook = (0, _react.renderHook)(function () {
+        var context = (0, _.useContext)(testUseCase);
+        var value = (0, _react2.useContext)(context);
+        return value;
+      }),
+      result = _renderHook.result;
+    var current = result.current;
+    (0, _globals.expect)(current).toBe(null);
+  });
+  (0, _globals.test)('should return the default context with value `null` if map has not saved a usecase with `ArgumentTypes.None` & `UseCaseModes.Normal`', function () {
+    var _renderHook2 = (0, _react.renderHook)(function () {
+        var context = (0, _.useContext)(testUseCase, _ArgumentTypes.ArgumentTypes.None);
+        var value = (0, _react2.useContext)(context);
+        return value;
+      }),
+      result = _renderHook2.result;
+    var current = result.current;
+    (0, _globals.expect)(current).toBe(null);
+  });
+  (0, _globals.test)('should return the default context with value `null` as unmount this hook', function () {
+    var _renderHook3 = (0, _react.renderHook)(function () {
+        var context = (0, _.useContext)(testUseCase, _ArgumentTypes.ArgumentTypes.None);
+        var value = (0, _react2.useContext)(context);
+        return value;
+      }),
+      result1 = _renderHook3.result,
+      unmount1 = _renderHook3.unmount;
+    var current1 = result1.current;
+    (0, _globals.expect)((0, _typeof2["default"])(current1)).toBe('object');
+    unmount1();
+    var _renderHook4 = (0, _react.renderHook)(function () {
+        var context = (0, _.useContext)(testUseCase, _ArgumentTypes.ArgumentTypes.None);
+        var value = (0, _react2.useContext)(context);
+        return value;
+      }),
+      result2 = _renderHook4.result;
+    var current2 = result2.current;
+    (0, _globals.expect)(current2).toBe(null);
+  });
+  (0, _globals.test)('should return a new context if map has not saved a usecase with `ArgumentTypes.Entity` & `UseCaseModes.Normal`', function () {
+    var _renderHook5 = (0, _react.renderHook)(function () {
+        return (0, _.useContext)(testUseCase, _ArgumentTypes.ArgumentTypes.Entity);
+      }),
+      result = _renderHook5.result;
+    var current = result.current;
+    (0, _globals.expect)((0, _typeof2["default"])(current)).toBe('object');
+  });
+});

package/lib/hooks/useContextUseCase/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useContextUseCase = void 0;
+var _useConstant = require("../useConstant");
+var _contextUseCase = require("../../usecases/contextUseCase");
+var useContextUseCase = exports.useContextUseCase = function useContextUseCase() {
+  return (0, _useConstant.useConstant)(function () {
+    return (0, _contextUseCase.contextUseCase)();
+  });
+};

package/lib/hooks/useContextValue/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useContextValue = void 0;
+var _useContextUseCase2 = require("../useContextUseCase");
+var _react = require("react");
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
+var useContextValue = exports.useContextValue = function useContextValue(context, argumentType) {
+  var _useContextUseCase = (0, _useContextUseCase2.useContextUseCase)(),
+    getGlobalContextValue = _useContextUseCase.getGlobalContextValue;
+  var contextValue = (0, _react.useContext)(context);
+  var globalContextValue = getGlobalContextValue(context);
+  var isGlobal = (argumentType & _ArgumentTypes.ArgumentTypes.Global) === _ArgumentTypes.ArgumentTypes.Global;
+  if (isGlobal) {
+    return globalContextValue;
+  }
+  return contextValue;
+};

package/lib/hooks/useContextualItem/index.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useContextualItem = void 0;
 var _ahooks = require("ahooks");
-var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
+var _Statuses = require("../../enums/Statuses");
 var _cacheCall = require("../../methods/cacheCall");
 var useContextualItem = exports.useContextualItem = function useContextualItem(contextItem, statuses, createFactory) {
   var depsKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
@@ -19,7 +19,7 @@ var useContextualItem = exports.useContextualItem = function useContextualItem(c
     });
   }, [depsKey, factoryRef]);
   return (0, _ahooks.useCreation)(function () {
-    var rootEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.RootEnabled) === _UseCaseStatuses.UseCaseStatuses.RootEnabled;
+    var rootEnabled = (statuses & _Statuses.Statuses.RootEnabled) === _Statuses.Statuses.RootEnabled;
     if (!rootEnabled && contextItem) {
       return contextItem;
     }