@mic-rexjs/usecases-react 2.0.2 → 2.1.1

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;

package/es/methods/getRenderingEntity/index.js

@@ -0,0 +1,13 @@
+import { UseCaseStatuses } from '../../enums/UseCaseStatuses';
+export const getRenderingEntity = (statuses, entityState, rootEntity, contextEntity) => {
+    if ((statuses & UseCaseStatuses.EntityRootEnabled) !== UseCaseStatuses.EntityRootEnabled) {
+        return contextEntity;
+    }
+    if ((statuses & UseCaseStatuses.StatelessEnabled) !== UseCaseStatuses.StatelessEnabled) {
+        return entityState;
+    }
+    if (typeof rootEntity === 'function') {
+        return rootEntity();
+    }
+    return rootEntity;
+};

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

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

package/es/methods/initEntityReducers/index.js

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

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

@@ -1,2 +1,2 @@
 import { ChangeCallback } from '../../configs/defaultUseCaseContext/types';
-export declare const triggerCallbacks: <T>(changeCallbackCollection: ChangeCallback<T>[], newEntity: T, oldEntity: T) => void;
+export declare const triggerCallbacks: <T>(callbacks: ChangeCallback<T>[], newEntity: T, oldEntity: T) => void;

package/es/methods/triggerCallbacks/index.js

@@ -1,5 +1,5 @@
-export const triggerCallbacks = (changeCallbackCollection, newEntity, oldEntity) => {
-    for (let { length: i } = changeCallbackCollection; i > 0; i--) {
-        changeCallbackCollection[i - 1](newEntity, oldEntity);
+export const triggerCallbacks = (callbacks, newEntity, oldEntity) => {
+    for (let { length: i } = callbacks; i > 0; i--) {
+        callbacks[i - 1](newEntity, oldEntity);
     }
 };

package/lib/enums/UseCaseArgumentTypes/index.js

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

package/lib/enums/UseCaseModeErrors/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UseCaseModeErrors = void 0;
+var UseCaseModeErrors;
+exports.UseCaseModeErrors = UseCaseModeErrors;
+(function (UseCaseModeErrors) {
+  UseCaseModeErrors["UnsupportedGlobal"] = "useUseCase does not support \"global\" mode with entity usecase";
+  UseCaseModeErrors["UnsupportedStateless"] = "useUseCase does not support \"stateless\" mode with non-entity usecase";
+})(UseCaseModeErrors || (exports.UseCaseModeErrors = UseCaseModeErrors = {}));

package/lib/enums/UseCaseStatuses/index.js

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

package/lib/hooks/useArgumentTypes/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _useConstant = require("../useConstant");
+var useArgumentTypes = function useArgumentTypes(args) {
+  return (0, _useConstant.useConstant)(function () {
+    var types = _UseCaseArgumentTypes.UseCaseArgumentTypes.None;
+    var _args = (0, _slicedToArray2["default"])(args, 3),
+      arg2 = _args[1],
+      arg3 = _args[2];
+    var type2 = (0, _typeof2["default"])(arg2);
+    if (type2 === 'function') {
+      types |= _UseCaseArgumentTypes.UseCaseArgumentTypes.Entity;
+    }
+    switch ('number') {
+      case type2:
+      case (0, _typeof2["default"])(arg3):
+        types |= _UseCaseArgumentTypes.UseCaseArgumentTypes.Mode;
+        break;
+    }
+    return types;
+  });
+};
+exports.useArgumentTypes = useArgumentTypes;

package/lib/hooks/useContextualItem/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useContextualItem = void 0;
+var _ahooks = require("ahooks");
+var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
+var _useMemoizedCall = require("../useMemoizedCall");
+var useContextualItem = function useContextualItem(statuses, contextItem, createFactory) {
+  var deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  var create = (0, _useMemoizedCall.useMemoizedCall)(createFactory, deps);
+  return (0, _ahooks.useCreation)(function () {
+    var rootEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.RootEnabled) === _UseCaseStatuses.UseCaseStatuses.RootEnabled;
+    if (!rootEnabled && contextItem) {
+      return contextItem;
+    }
+    return create();
+  }, [statuses, contextItem, create]);
+};
+exports.useContextualItem = useContextualItem;

package/lib/hooks/useEntity/index.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useEntity = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _usecases = require("@mic-rexjs/usecases");
+var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
+var _getRenderingEntity = require("../../methods/getRenderingEntity");
+var _useContextualItem = require("../useContextualItem");
+var _ahooks = require("ahooks");
+var _triggerWatchers = require("../../methods/triggerWatchers");
+var useEntity = function useEntity(statuses, rootEntity, contextStore, options) {
+  var _useState = (0, _react.useState)(rootEntity),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    entityState = _useState2[0],
+    setEntityState = _useState2[1];
+  var contextEntity = (contextStore === null || contextStore === void 0 ? void 0 : contextStore.getValue()) || null;
+  var renderingEntity = (0, _getRenderingEntity.getRenderingEntity)(statuses, entityState, rootEntity, contextEntity);
+  var optionsRef = (0, _ahooks.useLatest)(options);
+  var entityRootEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.EntityRootEnabled) === _UseCaseStatuses.UseCaseStatuses.EntityRootEnabled;
+  var store = (0, _useContextualItem.useContextualItem)(statuses, contextStore, function () {
+    if (!entityRootEnabled) {
+      return new _usecases.EntityStore(null);
+    }
+    var stateless = (statuses & _UseCaseStatuses.UseCaseStatuses.StatelessEnabled) === _UseCaseStatuses.UseCaseStatuses.StatelessEnabled;
+    return new _usecases.EntityStore(renderingEntity, function (newEntity) {
+      if (stateless) {
+        return;
+      }
+      setEntityState(newEntity);
+    });
+  });
+  if (entityRootEnabled) {
+    // 执行同步操作
+    store.setValue(renderingEntity);
+  }
+  (0, _react.useEffect)(function () {
+    if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
+      return;
+    }
+    var watcher = function watcher(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 ? void 0 : onChange(newEntity, oldEntity);
+    };
+    store.watch(watcher);
+    return function () {
+      store.unwatch(watcher);
+    };
+  }, [statuses, store, optionsRef]);
+  return (0, _ahooks.useCreation)(function () {
+    return [renderingEntity, store];
+  }, [renderingEntity, store]);
+};
+exports.useEntity = useEntity;

package/lib/hooks/useGlobalUseCase/index.js

@@ -1,25 +1,12 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useGlobalUseCase = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _useUseCase = require("../useUseCase");
 var _UseCaseModes = require("../../enums/UseCaseModes");
-var useGlobalUseCase = function useGlobalUseCase() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-  var arg1 = args[0],
-    arg2 = args[1],
-    rest = args.slice(2);
-  var isContextRoot = typeof arg2 === 'function';
-  var coreCollection = _useUseCase.useUseCase.apply(void 0, (0, _toConsumableArray2["default"])(isContextRoot ? [arg1, arg2, _UseCaseModes.UseCaseModes.Global].concat((0, _toConsumableArray2["default"])(rest)) : args));
-  if (isContextRoot) {
-    return coreCollection;
-  }
-  return coreCollection[1];
+var useGlobalUseCase = function useGlobalUseCase(useCase, options, deps) {
+  return (0, _useUseCase.useUseCase)(useCase, _UseCaseModes.UseCaseModes.Global, options, deps);
 };
 exports.useGlobalUseCase = useGlobalUseCase;

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

@@ -1,78 +1,26 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _typeof = require("@babel/runtime/helpers/typeof");
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _jsxRuntime = require("react/jsx-runtime");
 var _ = require(".");
-var _usecases = require("@mic-rexjs/usecases");
 var _globals = require("@jest/globals");
 var _UseCaseModes = require("../../enums/UseCaseModes");
 var _react = require("@testing-library/react");
-var _ahooks = require("ahooks");
 var useUseCaseModule = _interopRequireWildcard(require("../useUseCase"));
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-var numberUseCase = function numberUseCase() {
-  return (0, _usecases.entityUseCase)();
+var mathUseCase = function mathUseCase() {
+  return {};
 };
 (0, _globals.describe)('useGlobalUseCase', function () {
-  (0, _globals.describe)('`useGlobalUseCase` should work the same as `RootCoreCollectionHook`', function () {
+  (0, _globals.describe)('`useGlobalUseCase` should work the same as `GlobalPseudoCoreCollectionHook`', function () {
     (0, _globals.test)('check `useUseCase` has received correct arguments', function () {
       var useMockedUseCase = _globals.jest.fn();
       _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockImplementation(useMockedUseCase);
       (0, _react.renderHook)(function () {
-        (0, _.useGlobalUseCase)(1, numberUseCase);
+        (0, _.useGlobalUseCase)(mathUseCase);
       });
-      (0, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(1, numberUseCase, _UseCaseModes.UseCaseModes.Global);
+      (0, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(mathUseCase, _UseCaseModes.UseCaseModes.Global, void 0, void 0);
       _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockRestore();
     });
-    (0, _globals.test)('should should return `CoreCollection` with Provider', function () {
-      var _renderHook = (0, _react.renderHook)(function () {
-          return (0, _.useGlobalUseCase)(1, numberUseCase);
-        }),
-        result = _renderHook.result;
-      var current = result.current;
-      (0, _globals.expect)(current).toEqual([1, {
-        setEntity: _globals.expect.any(Function)
-      }, _globals.expect.any(Function)]);
-    });
-  });
-  (0, _globals.describe)('`useGlobalUseCase` should work the same as `GlobalReducersHook`', function () {
-    (0, _globals.test)('check `useUseCase` has received correct arguments', function () {
-      var useMockedUseCase = _globals.jest.fn();
-      _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockImplementation(useMockedUseCase);
-      (0, _react.renderHook)(function () {
-        try {
-          (0, _.useGlobalUseCase)(numberUseCase);
-        } catch (e) {
-          //
-        }
-      });
-      (0, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(numberUseCase);
-      _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockRestore();
-    });
-    (0, _globals.test)('should should only return reducers', function () {
-      var onChildMount = _globals.jest.fn();
-      var Child = function Child() {
-        var reducers = (0, _.useGlobalUseCase)(numberUseCase);
-        (0, _ahooks.useMount)(function () {
-          onChildMount(reducers);
-        });
-        return null;
-      };
-      var Parent = function Parent() {
-        var _useGlobalUseCase = (0, _.useGlobalUseCase)(1, numberUseCase),
-          _useGlobalUseCase2 = (0, _slicedToArray2["default"])(_useGlobalUseCase, 3),
-          Provider = _useGlobalUseCase2[2];
-        return (0, _jsxRuntime.jsx)(Provider, {
-          children: (0, _jsxRuntime.jsx)(Child, {})
-        });
-      };
-      (0, _react.render)((0, _jsxRuntime.jsx)(Parent, {}));
-      (0, _globals.expect)(onChildMount).toHaveBeenCalledWith({
-        setEntity: _globals.expect.any(Function)
-      });
-    });
   });
 });

package/lib/hooks/useMemoizedCall/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMemoizedCall = void 0;
+var _ahooks = require("ahooks");
+var _useCompareDeps = require("../useCompareDeps");
+var _cacheCall = require("../../methods/cacheCall");
+var useMemoizedCall = function useMemoizedCall(factory, deps) {
+  var depsKey = (0, _useCompareDeps.useCompareDeps)(deps);
+  var factoryRef = (0, _ahooks.useLatest)(factory);
+  return (0, _ahooks.useCreation)(function () {
+    void depsKey;
+    return (0, _cacheCall.cacheCall)(factoryRef.current, {
+      onCompare: function onCompare() {
+        return true;
+      }
+    });
+  }, [depsKey, factoryRef]);
+};
+exports.useMemoizedCall = useMemoizedCall;

package/lib/hooks/useProvider/index.js

@@ -5,33 +5,34 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useProvider = void 0;
-var _react = _interopRequireWildcard(require("react"));
 var _ahooks = require("ahooks");
-var _UseCaseModes = require("../../enums/UseCaseModes");
-var _useCompareDeps = require("../useCompareDeps");
+var _react = _interopRequireWildcard(require("react"));
 var _useConstantFn = require("../useConstantFn");
+var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-var useProvider = function useProvider(context, mode, entity, reducers, changeCallbackCollection) {
-  var isGlobal = (mode & _UseCaseModes.UseCaseModes.Global) === _UseCaseModes.UseCaseModes.Global;
-  var contextValueRef = (0, _ahooks.useLatest)({
-    entity: entity,
-    reducers: reducers,
-    changeCallbackCollection: changeCallbackCollection
-  });
-  var key = (0, _useCompareDeps.useCompareDeps)(isGlobal ? [] : [entity, reducers, changeCallbackCollection]);
-  var getContextValue = (0, _react.useCallback)(function () {
-    void key;
-    return contextValueRef.current;
-  }, [key, contextValueRef]);
-  var getContextValueRef = (0, _ahooks.useLatest)(getContextValue);
+var useProvider = function useProvider(statuses, context, store, reducers) {
+  var entity = store.getValue();
+  var contextValue = (0, _react.useMemo)(function () {
+    void entity;
+    if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) === _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
+      return {
+        store: store,
+        reducers: reducers
+      };
+    }
+    return {
+      reducers: reducers
+    };
+  }, [statuses, entity, store, reducers]);
+  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;
     return _react["default"].createElement(ContextProvider, {
-      value: getContextValueRef.current
+      value: contextValueRef.current
     }, withProviders.reduceRight(function (currentChildren, withProvider) {
       return _react["default"].createElement(withProvider, {}, currentChildren);
     }, children));

package/lib/hooks/useSafeMode/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSafeMode = void 0;
+var _UseCaseArgumentTypes = require("../../enums/UseCaseArgumentTypes");
+var _UseCaseModes = require("../../enums/UseCaseModes");
+var _useConstant = require("../useConstant");
+var _UseCaseModeErrors = require("../../enums/UseCaseModeErrors");
+var useSafeMode = function useSafeMode(unsafeMode, argumentTypes) {
+  return (0, _useConstant.useConstant)(function () {
+    if ((argumentTypes & _UseCaseArgumentTypes.UseCaseArgumentTypes.Entity) === _UseCaseArgumentTypes.UseCaseArgumentTypes.Entity) {
+      if ((unsafeMode & _UseCaseModes.UseCaseModes.Global) === _UseCaseModes.UseCaseModes.Global) {
+        throw _UseCaseModeErrors.UseCaseModeErrors.UnsupportedGlobal;
+      }
+      return unsafeMode;
+    }
+    if ((unsafeMode & _UseCaseModes.UseCaseModes.Stateless) === _UseCaseModes.UseCaseModes.Stateless) {
+      throw _UseCaseModeErrors.UseCaseModeErrors.UnsupportedStateless;
+    }
+    return unsafeMode;
+  });
+};
+exports.useSafeMode = useSafeMode;

package/lib/hooks/useStatelessUseCase/index.js

@@ -1,22 +1,12 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useStatelessUseCase = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _useUseCase = require("../useUseCase");
 var _UseCaseModes = require("../../enums/UseCaseModes");
-var useStatelessUseCase = function useStatelessUseCase() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-  var arg1 = args[0],
-    arg2 = args[1],
-    rest = args.slice(2);
-  var isContextRoot = typeof arg2 === 'function';
-  var coreCollection = _useUseCase.useUseCase.apply(void 0, (0, _toConsumableArray2["default"])(isContextRoot ? [arg1, arg2, _UseCaseModes.UseCaseModes.Stateless].concat((0, _toConsumableArray2["default"])(rest)) : args));
-  return coreCollection;
+var useStatelessUseCase = function useStatelessUseCase(entity, useCase, options, deps) {
+  return (0, _useUseCase.useUseCase)(entity, useCase, _UseCaseModes.UseCaseModes.Stateless, options, deps);
 };
 exports.useStatelessUseCase = useStatelessUseCase;

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

@@ -1,14 +1,10 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _typeof = require("@babel/runtime/helpers/typeof");
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _jsxRuntime = require("react/jsx-runtime");
 var _usecases = require("@mic-rexjs/usecases");
 var _globals = require("@jest/globals");
 var _UseCaseModes = require("../../enums/UseCaseModes");
 var _react = require("@testing-library/react");
-var _ahooks = require("ahooks");
 var useUseCaseModule = _interopRequireWildcard(require("../useUseCase"));
 var _ = require(".");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
@@ -24,7 +20,7 @@ var numberUseCase = function numberUseCase() {
       (0, _react.renderHook)(function () {
         (0, _.useStatelessUseCase)(1, numberUseCase);
       });
-      (0, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(1, numberUseCase, _UseCaseModes.UseCaseModes.Stateless);
+      (0, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(1, numberUseCase, _UseCaseModes.UseCaseModes.Stateless, void 0, void 0);
       _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockRestore();
     });
     (0, _globals.test)('should should return `CoreCollection` with Provider', function () {
@@ -35,44 +31,7 @@ var numberUseCase = function numberUseCase() {
       var current = result.current;
       (0, _globals.expect)(current).toEqual([1, {
         setEntity: _globals.expect.any(Function)
-      }, _globals.expect.any(Function)]);
-    });
-  });
-  (0, _globals.describe)('`useStatelessUseCase` should work the same as `ContextualCoreCollectionHook`', function () {
-    (0, _globals.test)('check `useUseCase` has received correct arguments', function () {
-      var useMockedUseCase = _globals.jest.fn();
-      _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockImplementation(useMockedUseCase);
-      (0, _react.renderHook)(function () {
-        try {
-          (0, _.useStatelessUseCase)(numberUseCase);
-        } catch (e) {
-          //
-        }
-      });
-      (0, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(numberUseCase);
-      _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockRestore();
-    });
-    (0, _globals.test)('should should only return reducers', function () {
-      var onChildMount = _globals.jest.fn();
-      var Child = function Child() {
-        var coreCollection = (0, _.useStatelessUseCase)(numberUseCase);
-        (0, _ahooks.useMount)(function () {
-          onChildMount(coreCollection);
-        });
-        return null;
-      };
-      var Parent = function Parent() {
-        var _useStatelessUseCase = (0, _.useStatelessUseCase)(1, numberUseCase),
-          _useStatelessUseCase2 = (0, _slicedToArray2["default"])(_useStatelessUseCase, 3),
-          Provider = _useStatelessUseCase2[2];
-        return (0, _jsxRuntime.jsx)(Provider, {
-          children: (0, _jsxRuntime.jsx)(Child, {})
-        });
-      };
-      (0, _react.render)((0, _jsxRuntime.jsx)(Parent, {}));
-      (0, _globals.expect)(onChildMount).toHaveBeenCalledWith([1, {
-        setEntity: _globals.expect.any(Function)
-      }, null]);
+      }, _globals.expect.any(Function), void 0, void 0]);
     });
   });
 });