@mic-rexjs/usecases-react 2.6.2 → 2.7.0

package/lib/hooks/useEntity/index.js

@@ -6,29 +6,38 @@ Object.defineProperty(exports, "__esModule", {
 exports.useEntity = void 0;
 var _react = require("react");
 var _usecases = require("@mic-rexjs/usecases");
-var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
+var _Statuses = require("../../enums/Statuses");
 var _useContextualItem = require("../useContextualItem");
 var _ahooks = require("ahooks");
 var _triggerWatchers = require("../../methods/triggerWatchers");
 var _useRuntimeEntity = require("../useRuntimeEntity");
-var useEntity = exports.useEntity = function useEntity(statuses, rootEntity, contextStore, options, depsKey) {
+var useEntity = exports.useEntity = function useEntity(statuses, entityArg, contextStore, options) {
   var update = (0, _ahooks.useUpdate)();
   var optionsRef = (0, _ahooks.useLatest)(options);
   var contextEntity = contextStore ? contextStore.value : null;
-  var entityEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) === _UseCaseStatuses.UseCaseStatuses.EntityEnabled;
-  var entityRootEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.EntityRootEnabled) === _UseCaseStatuses.UseCaseStatuses.EntityRootEnabled;
+  var entityEnabled = (statuses & _Statuses.Statuses.EntityEnabled) === _Statuses.Statuses.EntityEnabled;
+  var entityRootEnabled = (statuses & _Statuses.Statuses.EntityRootEnabled) === _Statuses.Statuses.EntityRootEnabled;
   var store = (0, _useContextualItem.useContextualItem)(contextStore, statuses, function () {
     if (!entityRootEnabled) {
       return new _usecases.EntityStore(null);
     }
-    var isFunction = typeof rootEntity === 'function';
-    return new _usecases.EntityStore(isFunction ? rootEntity() : rootEntity, {
-      onChange: function onChange() {
-        update();
-      }
-    });
+    var isFunction = typeof entityArg === 'function';
+    return new _usecases.EntityStore(isFunction ? entityArg() : entityArg);
+  });
+  var runtimeEntity = (0, _useRuntimeEntity.useRuntimeEntity)(store, entityArg, contextEntity, statuses);
+  var onEntityChange = (0, _ahooks.useMemoizedFn)(function (newEntity, oldEntity) {
+    var _optionsRef$current = optionsRef.current,
+      onChange = _optionsRef$current.onChange,
+      watch = _optionsRef$current.watch;
+    var globalEnabled = (statuses & _Statuses.Statuses.GlobalEnabled) === _Statuses.Statuses.GlobalEnabled;
+    if (watch) {
+      (0, _triggerWatchers.triggerWatchers)(watch, newEntity, oldEntity);
+    }
+    onChange === null || onChange === void 0 || onChange(newEntity, oldEntity);
+    if (entityRootEnabled || globalEnabled) {
+      update();
+    }
   });
-  var runtimeEntity = (0, _useRuntimeEntity.useRuntimeEntity)(store, rootEntity, contextEntity, statuses);
   if (entityRootEnabled) {
     // 执行同步操作
     store.value = runtimeEntity;
@@ -37,20 +46,11 @@ var useEntity = exports.useEntity = function useEntity(statuses, rootEntity, con
     if (!entityEnabled) {
       return;
     }
-    var onEntityChange = function onEntityChange(newEntity, oldEntity) {
-      var _optionsRef$current = optionsRef.current,
-        onChange = _optionsRef$current.onChange,
-        watch = _optionsRef$current.watch;
-      if (watch) {
-        (0, _triggerWatchers.triggerWatchers)(watch, newEntity, oldEntity);
-      }
-      onChange === null || onChange === void 0 || onChange(newEntity, oldEntity);
-    };
     store.watch(onEntityChange);
     return function () {
       store.unwatch(onEntityChange);
     };
-  }, [entityEnabled, store, depsKey, optionsRef]);
+  }, [entityEnabled, store, onEntityChange]);
   return (0, _ahooks.useCreation)(function () {
     return [runtimeEntity, store];
   }, [runtimeEntity, store]);

package/lib/hooks/useFullArguments/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFullArguments = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
+var _useContextUseCase2 = require("../useContextUseCase");
+var useFullArguments = exports.useFullArguments = function useFullArguments(args, argumentTypes) {
+  var _args = (0, _slicedToArray2["default"])(args, 4),
+    arg1 = _args[0],
+    arg2 = _args[1],
+    arg3 = _args[2],
+    arg4 = _args[3];
+  var withoutEntity = (argumentTypes & _ArgumentTypes.ArgumentTypes.Entity) !== _ArgumentTypes.ArgumentTypes.Entity;
+  var _useContextUseCase = (0, _useContextUseCase2.useContextUseCase)(),
+    isGlobal = _useContextUseCase.isGlobal;
+  var global = isGlobal(arg1);
+  if (withoutEntity || global) {
+    return [null, arg1, arg2 || {}, arg3 || []];
+  }
+  return [arg1, arg2, arg3 || {}, arg4 || []];
+};

package/lib/hooks/useProvider/index.js

@@ -5,36 +5,29 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useProvider = void 0;
-var _ahooks = require("ahooks");
 var _react = _interopRequireWildcard(require("react"));
+var _ahooks = require("ahooks");
 var _useConstantFn = require("../useConstantFn");
-var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
+var _useContextUseCase2 = require("../useContextUseCase");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
 var useProvider = exports.useProvider = function useProvider(statuses, context, store, reducers) {
   var entity = store.value;
+  var _useContextUseCase = (0, _useContextUseCase2.useContextUseCase)(),
+    createContextValue = _useContextUseCase.createContextValue;
   var contextValue = (0, _react.useMemo)(function () {
     void entity;
-    if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) === _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
-      return {
-        store: store,
-        reducers: reducers,
-        statuses: statuses
-      };
-    }
-    return {
-      reducers: reducers,
-      statuses: statuses
-    };
-  }, [statuses, entity, store, reducers]);
+    return createContextValue(store, reducers, statuses);
+  }, [statuses, entity, store, reducers, createContextValue]);
   var contextValueRef = (0, _ahooks.useLatest)(contextValue);
   return (0, _useConstantFn.useConstantFn)(function (_ref) {
     var children = _ref.children,
       _ref$with = _ref["with"],
       withProviders = _ref$with === void 0 ? [] : _ref$with;
     var ContextProvider = context.Provider;
+    var value = contextValueRef.current;
     return _react["default"].createElement(ContextProvider, {
-      value: contextValueRef.current
+      value: value
     }, withProviders.reduceRight(function (currentChildren, withProvider) {
       return _react["default"].createElement(withProvider, {}, currentChildren);
     }, children));

package/lib/hooks/useRuntimeEntity/index.js

@@ -4,21 +4,21 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useRuntimeEntity = void 0;
-var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
+var _Statuses = require("../../enums/Statuses");
 var _react = require("react");
-var useRuntimeEntity = exports.useRuntimeEntity = function useRuntimeEntity(store, rootEntity, contextEntity, statuses) {
-  var prevRootEntityRef = (0, _react.useRef)(rootEntity);
-  var entityRootDisabled = (statuses & _UseCaseStatuses.UseCaseStatuses.EntityRootEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityRootEnabled;
+var useRuntimeEntity = exports.useRuntimeEntity = function useRuntimeEntity(store, entityArg, contextEntity, statuses) {
+  var prevEntityArgRef = (0, _react.useRef)(entityArg);
+  var entityRootDisabled = (statuses & _Statuses.Statuses.EntityRootEnabled) !== _Statuses.Statuses.EntityRootEnabled;
   if (entityRootDisabled) {
     return contextEntity;
   }
-  var isFunction = typeof rootEntity === 'function';
-  var prevRootEntity = prevRootEntityRef.current;
+  var isFunction = typeof entityArg === 'function';
+  var prevEntityArg = prevEntityArgRef.current;
   switch (true) {
     case isFunction:
-    case prevRootEntity === rootEntity:
+    case prevEntityArg === entityArg:
       return store.value;
   }
-  prevRootEntityRef.current = rootEntity;
-  return rootEntity;
+  prevEntityArgRef.current = entityArg;
+  return entityArg;
 };

package/lib/hooks/useStatuses/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useStatuses = void 0;
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
+var _Statuses = require("../../enums/Statuses");
+var _ahooks = require("ahooks");
+var useStatuses = exports.useStatuses = function useStatuses(argumentTypes, contextValue) {
+  return (0, _ahooks.useCreation)(function () {
+    var statuses = _Statuses.Statuses.None;
+    var _ref = contextValue || {},
+      store = _ref.store;
+    var hasEntity = (argumentTypes & _ArgumentTypes.ArgumentTypes.Entity) === _ArgumentTypes.ArgumentTypes.Entity;
+    var isGlobal = (argumentTypes & _ArgumentTypes.ArgumentTypes.Global) === _ArgumentTypes.ArgumentTypes.Global;
+    if (hasEntity && !isGlobal) {
+      statuses |= _Statuses.Statuses.EntityRootEnabled;
+    }
+    if (contextValue || isGlobal) {
+      statuses |= _Statuses.Statuses.ContextEnabled;
+    } else {
+      statuses |= _Statuses.Statuses.RootEnabled;
+    }
+    if (store || isGlobal) {
+      statuses |= _Statuses.Statuses.EntityEnabled;
+    }
+    if (isGlobal) {
+      statuses |= _Statuses.Statuses.GlobalEnabled;
+    }
+    return statuses;
+  }, [argumentTypes, contextValue]);
+};

package/lib/hooks/useUseCase/index.js

@@ -8,28 +8,28 @@ exports.useUseCase = void 0;
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _ahooks = require("ahooks");
-var _react = require("react");
 var _useConstantFn = require("../useConstantFn");
 var _useProvider = require("../useProvider");
 var _initEntityReducers = require("../../methods/initEntityReducers");
-var _useUseCaseContext = require("../useUseCaseContext");
+var _useContext = require("../useContext");
 var _useIsRenderingRef = require("../useIsRenderingRef");
-var _fillArguments = require("../../methods/fillArguments");
 var _useArgumentTypes = require("../useArgumentTypes");
-var _useUseCaseStatuses = require("../useUseCaseStatuses");
-var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
+var _useStatuses = require("../useStatuses");
+var _Statuses = require("../../enums/Statuses");
 var _useEntity3 = require("../useEntity");
 var _useContextualItem = require("../useContextualItem");
 var _cacheCalls = require("../../methods/cacheCalls");
 var _useCompareDeps = require("../useCompareDeps");
 var _captureCalls = require("../../methods/captureCalls");
+var _useFullArguments = require("../useFullArguments");
+var _useContextValue = require("../useContextValue");
 var useUseCase = exports.useUseCase = function useUseCase() {
   var isRenderingRef = (0, _useIsRenderingRef.useIsRenderingRef)();
   for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
     args[_key] = arguments[_key];
   }
   var argumentTypes = (0, _useArgumentTypes.useArgumentTypes)(args);
-  var fullArguments = (0, _fillArguments.fillArguments)(args, argumentTypes);
+  var fullArguments = (0, _useFullArguments.useFullArguments)(args, argumentTypes);
   var _fullArguments = (0, _slicedToArray2["default"])(fullArguments, 4),
     unsafeEntity = _fullArguments[0],
     unsafeUsecase = _fullArguments[1],
@@ -38,10 +38,10 @@ var useUseCase = exports.useUseCase = function useUseCase() {
   var unkownUsecase = (0, _useConstantFn.useConstantFn)(unsafeUsecase);
   var usecase = unkownUsecase;
   var entityUseCase = unkownUsecase;
-  var context = (0, _useUseCaseContext.useUseCaseContext)(unkownUsecase, argumentTypes);
-  var contextValue = (0, _react.useContext)(context);
+  var context = (0, _useContext.useContext)(unkownUsecase, argumentTypes);
+  var contextValue = (0, _useContextValue.useContextValue)(context, argumentTypes);
   var entityContextValue = contextValue;
-  var statuses = (0, _useUseCaseStatuses.useUseCaseStatuses)(argumentTypes, contextValue);
+  var statuses = (0, _useStatuses.useStatuses)(argumentTypes, contextValue);
   var optionsRef = (0, _ahooks.useLatest)(options);
   var depsKey = (0, _useCompareDeps.useCompareDeps)(deps);
   var _ref = contextValue || {},
@@ -50,7 +50,7 @@ var useUseCase = exports.useUseCase = function useUseCase() {
   var _ref2 = entityContextValue || {},
     _ref2$store = _ref2.store,
     contextStore = _ref2$store === void 0 ? null : _ref2$store;
-  var _useEntity = (0, _useEntity3.useEntity)(statuses, unsafeEntity, contextStore, options, depsKey),
+  var _useEntity = (0, _useEntity3.useEntity)(statuses, unsafeEntity, contextStore, options),
     _useEntity2 = (0, _slicedToArray2["default"])(_useEntity, 2),
     entity = _useEntity2[0],
     store = _useEntity2[1];
@@ -59,7 +59,7 @@ var useUseCase = exports.useUseCase = function useUseCase() {
       var _optionsRef$current$k, _optionsRef$current;
       return (_optionsRef$current$k = (_optionsRef$current = optionsRef.current)[key]) === null || _optionsRef$current$k === void 0 ? void 0 : _optionsRef$current$k.call.apply(_optionsRef$current$k, [_optionsRef$current].concat((0, _toConsumableArray2["default"])(callArgs)));
     });
-    if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
+    if ((statuses & _Statuses.Statuses.EntityEnabled) !== _Statuses.Statuses.EntityEnabled) {
       return usecase(opts);
     }
     var hookOptions = opts;
@@ -67,10 +67,10 @@ var useUseCase = exports.useUseCase = function useUseCase() {
   }, depsKey);
   var Provider = (0, _useProvider.useProvider)(statuses, context, store, reducers);
   return (0, _ahooks.useCreation)(function () {
-    if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
+    if ((statuses & _Statuses.Statuses.EntityEnabled) !== _Statuses.Statuses.EntityEnabled) {
       return reducers;
     }
-    var rootEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.RootEnabled) === _UseCaseStatuses.UseCaseStatuses.RootEnabled;
+    var rootEnabled = (statuses & _Statuses.Statuses.RootEnabled) === _Statuses.Statuses.RootEnabled;
     var cachedReducers = (0, _cacheCalls.cacheCalls)(reducers, {
       onShouldCache: function onShouldCache() {
         return isRenderingRef.current;

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

@@ -16,6 +16,7 @@ var _react = require("@testing-library/react");
 var _ = require(".");
 var _ahooks = require("ahooks");
 var _react2 = require("react");
+var _registerGlobalUseCase = require("../../methods/registerGlobalUseCase");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _asyncIterator(r) { var n, t, o, e = 2; for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) { if (t && null != (n = r[t])) return n.call(r); if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r)); t = "@@asyncIterator", o = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
@@ -1468,7 +1469,7 @@ var useDeepCompareUpdate = function useDeepCompareUpdate(callback, deps) {
       (0, _globals.expect)(onBooleanMount).toHaveBeenCalledWith(true);
     });
   });
-  (0, _globals.describe)('`useUseCase` should work the same as useContextualCoreCollection', function () {
+  (0, _globals.describe)('`useUseCase` should work the same as `useContextualCoreCollection`', function () {
     (0, _globals.test)('Should trigger Parent & Child to update', function () {
       var onParentUpdate = _globals.jest.fn();
       var onChildUpdate = _globals.jest.fn();
@@ -1918,6 +1919,150 @@ var useDeepCompareUpdate = function useDeepCompareUpdate(callback, deps) {
         oldValue: EXT_1
       });
     });
+    (0, _globals.test)('global usecase should share the entity to any components', function () {
+      var onValue = _globals.jest.fn();
+      var firstButtonText = 'first button';
+      var secondButtonText = 'second button';
+      var numberUseCase = function numberUseCase() {
+        return (0, _usecases.entityUseCase)();
+      };
+      var A = function A() {
+        var _useUseCase54 = (0, _.useUseCase)(numberUseCase),
+          _useUseCase55 = (0, _slicedToArray2["default"])(_useUseCase54, 2),
+          entity = _useUseCase55[0],
+          setEntity = _useUseCase55[1].setEntity;
+        var onButtonClick = function onButtonClick() {
+          setEntity(2);
+        };
+        (0, _ahooks.useMount)(function () {
+          onValue(entity);
+        });
+        return (0, _jsxRuntime.jsx)("div", {
+          children: (0, _jsxRuntime.jsx)("button", {
+            onClick: onButtonClick,
+            children: firstButtonText
+          })
+        });
+      };
+      var B = function B() {
+        var _useUseCase56 = (0, _.useUseCase)(numberUseCase),
+          _useUseCase57 = (0, _slicedToArray2["default"])(_useUseCase56, 2),
+          entity = _useUseCase57[0],
+          setEntity = _useUseCase57[1].setEntity;
+        var onButtonClick = function onButtonClick() {
+          setEntity(3);
+        };
+        (0, _ahooks.useMount)(function () {
+          onValue(entity);
+        });
+        return (0, _jsxRuntime.jsx)("div", {
+          children: (0, _jsxRuntime.jsx)("button", {
+            onClick: onButtonClick,
+            children: secondButtonText
+          })
+        });
+      };
+      (0, _registerGlobalUseCase.registerGlobalUseCase)(1, numberUseCase);
+      (0, _react.render)((0, _jsxRuntime.jsx)(A, {}));
+      (0, _globals.expect)(onValue).toHaveBeenNthCalledWith(1, 1);
+      _react.fireEvent.click(_react.screen.getByText(firstButtonText));
+      (0, _react.render)((0, _jsxRuntime.jsx)(B, {}));
+      (0, _globals.expect)(onValue).toHaveBeenNthCalledWith(2, 2);
+      _react.fireEvent.click(_react.screen.getByText(secondButtonText));
+    });
+    (0, _globals.test)('global usecase should trigger `onChange` in any components when entity has changed', function () {
+      var onValueChange1 = _globals.jest.fn();
+      var onValueChange2 = _globals.jest.fn();
+      var firstButtonText = 'first button';
+      var secondButtonText = 'second button';
+      var numberUseCase = function numberUseCase() {
+        return (0, _usecases.entityUseCase)();
+      };
+      var A = function A() {
+        var _useUseCase58 = (0, _.useUseCase)(numberUseCase, {
+            onChange: function onChange(value) {
+              onValueChange1(value);
+            }
+          }),
+          _useUseCase59 = (0, _slicedToArray2["default"])(_useUseCase58, 2),
+          setEntity = _useUseCase59[1].setEntity;
+        var onButtonClick = function onButtonClick() {
+          setEntity(2);
+        };
+        return (0, _jsxRuntime.jsx)("div", {
+          children: (0, _jsxRuntime.jsx)("button", {
+            onClick: onButtonClick,
+            children: firstButtonText
+          })
+        });
+      };
+      var B = function B() {
+        var _useUseCase60 = (0, _.useUseCase)(numberUseCase, {
+            onChange: function onChange(value) {
+              onValueChange2(value);
+            }
+          }),
+          _useUseCase61 = (0, _slicedToArray2["default"])(_useUseCase60, 2),
+          setEntity = _useUseCase61[1].setEntity;
+        var onButtonClick = function onButtonClick() {
+          setEntity(3);
+        };
+        return (0, _jsxRuntime.jsx)("div", {
+          children: (0, _jsxRuntime.jsx)("button", {
+            onClick: onButtonClick,
+            children: secondButtonText
+          })
+        });
+      };
+      (0, _registerGlobalUseCase.registerGlobalUseCase)(1, numberUseCase);
+      (0, _react.render)((0, _jsxRuntime.jsx)(A, {}));
+      _react.fireEvent.click(_react.screen.getByText(firstButtonText));
+      (0, _globals.expect)(onValueChange1).toHaveBeenNthCalledWith(1, 2);
+      (0, _react.render)((0, _jsxRuntime.jsx)(B, {}));
+      _react.fireEvent.click(_react.screen.getByText(secondButtonText));
+      (0, _globals.expect)(onValueChange1).toHaveBeenNthCalledWith(2, 3);
+      (0, _globals.expect)(onValueChange2).toHaveBeenNthCalledWith(1, 3);
+    });
+    (0, _globals.test)('global usecase should trigger update for components when entity has changed', function () {
+      var onUpdate1 = _globals.jest.fn();
+      var onUpdate2 = _globals.jest.fn();
+      var buttonText = 'my button';
+      var numberUseCase = function numberUseCase() {
+        return (0, _usecases.entityUseCase)();
+      };
+      var A = function A() {
+        var _useUseCase62 = (0, _.useUseCase)(numberUseCase),
+          _useUseCase63 = (0, _slicedToArray2["default"])(_useUseCase62, 2),
+          entity = _useUseCase63[0],
+          setEntity = _useUseCase63[1].setEntity;
+        var onButtonClick = function onButtonClick() {
+          setEntity(6);
+        };
+        (0, _ahooks.useUpdateEffect)(function () {
+          onUpdate1(entity);
+        }, [entity]);
+        return (0, _jsxRuntime.jsx)("div", {
+          children: (0, _jsxRuntime.jsx)("button", {
+            onClick: onButtonClick,
+            children: buttonText
+          })
+        });
+      };
+      var B = function B() {
+        var _useUseCase64 = (0, _.useUseCase)(numberUseCase),
+          _useUseCase65 = (0, _slicedToArray2["default"])(_useUseCase64, 1),
+          entity = _useUseCase65[0];
+        (0, _ahooks.useUpdateEffect)(function () {
+          onUpdate2(entity);
+        }, [entity]);
+        return (0, _jsxRuntime.jsx)(A, {});
+      };
+      (0, _registerGlobalUseCase.registerGlobalUseCase)(1, numberUseCase);
+      (0, _react.render)((0, _jsxRuntime.jsx)(B, {}));
+      _react.fireEvent.click(_react.screen.getByText(buttonText));
+      (0, _globals.expect)(onUpdate1).toHaveBeenNthCalledWith(1, 6);
+      (0, _globals.expect)(onUpdate2).toHaveBeenNthCalledWith(1, 6);
+    });
   });
   (0, _globals.describe)('`useUseCase` should work the same as `useReducers`', function () {
     (0, _globals.test)('`entity` should equal `defaultFile`', function () {
@@ -1971,8 +2116,8 @@ var useDeepCompareUpdate = function useDeepCompareUpdate(callback, deps) {
     (0, _globals.test)('reducer call should not be cached if component is at rendering phase', function () {
       var buttonText = 'button';
       var CacheTestComponent = function CacheTestComponent() {
-        var _useUseCase54 = (0, _.useUseCase)(mathUseCase),
-          subtraction = _useUseCase54.subtraction;
+        var _useUseCase66 = (0, _.useUseCase)(mathUseCase),
+          subtraction = _useUseCase66.subtraction;
         var update = (0, _ahooks.useUpdate)();
         var onClick = function onClick() {
           update();
@@ -1995,8 +2140,8 @@ var useDeepCompareUpdate = function useDeepCompareUpdate(callback, deps) {
     (0, _globals.test)('reducer call should not be cached if component is not at rendering phase', function () {
       var buttonText = 'button';
       var CacheTestComponent = function CacheTestComponent() {
-        var _useUseCase55 = (0, _.useUseCase)(mathUseCase),
-          subtraction = _useUseCase55.subtraction;
+        var _useUseCase67 = (0, _.useUseCase)(mathUseCase),
+          subtraction = _useUseCase67.subtraction;
         var onClick = function onClick() {
           subtraction(5, 3);
         };
@@ -2024,8 +2169,8 @@ var useDeepCompareUpdate = function useDeepCompareUpdate(callback, deps) {
       var count = 0;
       var buttonText = 'button';
       var StringUseCaseTestComponent = function StringUseCaseTestComponent() {
-        var _useUseCase56 = (0, _.useUseCase)(mathUseCase),
-          subtraction = _useUseCase56.subtraction;
+        var _useUseCase68 = (0, _.useUseCase)(mathUseCase),
+          subtraction = _useUseCase68.subtraction;
         var update = (0, _ahooks.useUpdate)();
         subtraction(5, count++);
         var onUpdate = function onUpdate() {

package/lib/index.js

@@ -9,6 +9,12 @@ Object.defineProperty(exports, "UseCaseFragment", {
     return _UseCaseFragment.UseCaseFragment;
   }
 });
+Object.defineProperty(exports, "registerGlobalUseCase", {
+  enumerable: true,
+  get: function get() {
+    return _registerGlobalUseCase.registerGlobalUseCase;
+  }
+});
 Object.defineProperty(exports, "useUseCase", {
   enumerable: true,
   get: function get() {
@@ -16,4 +22,5 @@ Object.defineProperty(exports, "useUseCase", {
   }
 });
 var _UseCaseFragment = require("./components/UseCaseFragment");
-var _useUseCase = require("./hooks/useUseCase");
+var _useUseCase = require("./hooks/useUseCase");
+var _registerGlobalUseCase = require("./methods/registerGlobalUseCase");

package/lib/methods/registerGlobalUseCase/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.registerGlobalUseCase = void 0;
+var _contextUseCase2 = require("../../usecases/contextUseCase");
+var _contextUseCase = (0, _contextUseCase2.contextUseCase)(),
+  registerGlobalUseCase = exports.registerGlobalUseCase = _contextUseCase.registerGlobalUseCase;

package/lib/usecases/contextUseCase/index.js

@@ -1,27 +1,110 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.contextUseCase = void 0;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-var contextUseCase = exports.contextUseCase = function contextUseCase() {
-  var hasContext = function hasContext(target) {
-    if ((0, _typeof2["default"])(target) !== 'object') {
-      return false;
-    }
-    if (!Array.isArray(target)) {
-      return false;
-    }
-    var length = target.length;
-    var reducers = target[1];
-    if (length < 2) {
-      return false;
-    }
-    return (0, _typeof2["default"])(reducers) === 'object';
+var _usecases = require("@mic-rexjs/usecases");
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
+var _react = require("react");
+var _Statuses = require("../../enums/Statuses");
+var _initEntityReducers = require("../../methods/initEntityReducers");
+var contextUseCase = exports.contextUseCase = (0, _usecases.createUseCase)(function () {
+  var referenceMap = new Map();
+  var globalContextMap = new Map();
+  var globalContextValueMap = new Map();
+  var defaultUseCaseContext = (0, _react.createContext)(null);
+  return function () {
+    var createContextValue = function createContextValue(store, reducers, statuses) {
+      if ((statuses & _Statuses.Statuses.EntityEnabled) === _Statuses.Statuses.EntityEnabled) {
+        return {
+          store: store,
+          reducers: reducers,
+          statuses: statuses
+        };
+      }
+      return {
+        reducers: reducers,
+        statuses: statuses
+      };
+    };
+    var getGlobalContextValue = function getGlobalContextValue(key) {
+      var context = typeof key === 'function' ? globalContextMap.get(key) : key;
+      return globalContextValueMap.get(context) || null;
+    };
+    var isGlobal = function isGlobal(usecase) {
+      return globalContextMap.has(usecase);
+    };
+    var registerUseCase = function registerUseCase(usecase, argumentTypes) {
+      if (referenceMap.has(usecase)) {
+        var reference = referenceMap.get(usecase);
+        var value = reference.value,
+          times = reference.times;
+        referenceMap.set(usecase, {
+          value: value,
+          times: times + 1
+        });
+        return value;
+      }
+      if ((argumentTypes & _ArgumentTypes.ArgumentTypes.Entity) !== _ArgumentTypes.ArgumentTypes.Entity) {
+        return defaultUseCaseContext;
+      }
+      var context = (0, _react.createContext)(null);
+      referenceMap.set(usecase, {
+        value: context,
+        times: 1
+      });
+      return context;
+    };
+    var unregisterUseCase = function unregisterUseCase(usecase, argumentTypes) {
+      if ((argumentTypes & _ArgumentTypes.ArgumentTypes.Entity) !== _ArgumentTypes.ArgumentTypes.Entity) {
+        return false;
+      }
+      if (!referenceMap.has(usecase)) {
+        return false;
+      }
+      var reference = referenceMap.get(usecase);
+      var value = reference.value,
+        times = reference.times;
+      if (times === 1) {
+        referenceMap["delete"](usecase);
+      } else {
+        referenceMap.set(usecase, {
+          value: value,
+          times: times - 1
+        });
+      }
+      return true;
+    };
+    var registerGlobalUseCase = function registerGlobalUseCase(entity, usecase) {
+      if (globalContextMap.has(usecase)) {
+        return;
+      }
+      var store = new _usecases.EntityStore(entity);
+      var reducers = (0, _initEntityReducers.initEntityReducers)(usecase, store, {});
+      var contextValue = createContextValue(store, reducers, _Statuses.Statuses.GlobalEnabled);
+      var context = registerUseCase(usecase, _ArgumentTypes.ArgumentTypes.GlobalEntity);
+      globalContextMap.set(usecase, context);
+      globalContextValueMap.set(context, contextValue);
+    };
+    var unregisterGlobalUseCase = function unregisterGlobalUseCase(usecase) {
+      if (!globalContextMap.has(usecase)) {
+        return false;
+      }
+      var context = globalContextMap.get(usecase);
+      globalContextMap["delete"](usecase);
+      globalContextValueMap["delete"](context);
+      referenceMap["delete"](usecase);
+      return true;
+    };
+    return {
+      createContextValue: createContextValue,
+      getGlobalContextValue: getGlobalContextValue,
+      isGlobal: isGlobal,
+      registerUseCase: registerUseCase,
+      registerGlobalUseCase: registerGlobalUseCase,
+      unregisterUseCase: unregisterUseCase,
+      unregisterGlobalUseCase: unregisterGlobalUseCase
+    };
   };
-  return {
-    hasContext: hasContext
-  };
-};
+});