@mic-rexjs/usecases-react 2.1.3 → 2.2.0

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

@@ -1,21 +1,21 @@
-import { EntityReducerMap, EntityReducers, EntityUseCase, ReducerMap, Reducers, UseCase } from '@mic-rexjs/usecases';
+import { EntityReducers, EntityUseCase, Reducers, UseCase } from '@mic-rexjs/usecases';
 import { UseCaseProvider } from '../useProvider/types';
 import { UseCaseModes } from '../../enums/UseCaseModes';
 import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
-export type RootCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = [
+import { GlobalReducers, GlobalUseCase, SymbolSet, SymbolSetTarget } from '@mic-rexjs/usecases/es/types';
+export interface NonEntitySymbolSet extends SymbolSet {
+    entity?: never;
+}
+export type RootCoreCollection<T, TEntityReducers extends EntityReducers<T>> = [
     entity: T,
     reducers: ContextualEntityReducers<T, TEntityReducers>,
     Provider: UseCaseProvider
 ];
-export type ContextualCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = [
+export type ContextualCoreCollection<T, TEntityReducers extends EntityReducers<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 type CoreCollection<T, TEntityReducers extends EntityReducers<T>> = RootCoreCollection<T, TEntityReducers> | ContextualCoreCollection<T, TEntityReducers>;
 export interface EntityGetter<T> {
     (): T;
 }
@@ -45,49 +45,23 @@ export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extend
     options?: TUseCaseOptions;
 }
 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;
+}
+export interface ContextualReducersHook {
+    <T, TGlobalReducers extends GlobalReducers<T>>(usecase: GlobalUseCase<T, TGlobalReducers> & UseCase<EntityReducers<T>>): ContextualEntityReducers<T, TGlobalReducers>;
+}
 export interface ContextualCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducers<T>>(usecase: EntityUseCase<T, TEntityReducers> & 
-    /**
-     * 如果不使用 `&`，那么很多情况下 `options` 类型无法被正确推导；
-     * 因为使用 `&` 是为了让该参数 `usecase` 的泛型 `T` 推导占优先级，
-     * 从而保证 `options` 里的泛型 `T` 是根据 `usecase` 来推导的。
-     */
-    UseCase<EntityReducerMap<T>>, options?: UseCaseHookContextualOptions<T>): ContextualCoreCollection<T, TEntityReducers>;
+    <T, TEntityReducers extends EntityReducers<T>>(usecase: EntityUseCase<T, TEntityReducers> & UseCase<EntityReducers<T>>, options?: UseCaseHookContextualOptions<T>): ContextualCoreCollection<T, TEntityReducers>;
 }
 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<EntityReducerMap<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): RootCoreCollection<T, TEntityReducers>;
+    <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>;
 }
 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<EntityReducerMap<T>, TUseCaseOptions>, 
-    /**
-     * currently, only support `UseCaseModes.Stateless`
-     */
-    mode: UseCaseModes, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): RootCoreCollection<T, TEntityReducers>;
-}
-export interface PseudoCoreCollectionHook {
-    <T extends Reducers, TUseCaseOptions extends object = object>(usecase: UseCase<T, TUseCaseOptions>, 
-    /**
-     * currently, only support `UseCaseModes.Global`
-     */
-    mode: UseCaseModes, options?: TUseCaseOptions, deps?: unknown[]): PseudoCoreCollection<T>;
-}
-export interface ReducersHook {
-    <T extends Reducers, TUseCaseOptions extends object = object>(usecase: UseCase<T, TUseCaseOptions>, options?: TUseCaseOptions, deps?: unknown[]): T;
+    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(entity: T | EntityGetter<T>, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & UseCase<EntityReducers<T>, TUseCaseOptions>, mode: UseCaseModes, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): RootCoreCollection<T, TEntityReducers>;
 }
 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 {
+export type UseCaseHookParameters = Parameters<ReducersHook> | Parameters<ContextualReducersHook> | Parameters<ContextualCoreCollectionHook> | Parameters<RootCoreCollectionHook> | Parameters<ModeCoreCollectionHook>;
+export interface UseCaseHook extends ReducersHook, ContextualReducersHook, CoreCollectionHook {
 }

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

@@ -1,5 +1,4 @@
-import { ReducerMap, UseCase } from '@mic-rexjs/usecases';
+import { Reducers, 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;
+export declare const useUseCaseContext: <T extends Reducers, TUseCaseOptions extends object, TContext extends UseCaseContext<UseCaseContextValue<T>>>(usecase: UseCase<T, TUseCaseOptions>, argumentTypes?: UseCaseArgumentTypes) => TContext;

package/es/hooks/useUseCaseContext/index.js

@@ -3,9 +3,8 @@ import { usecaseContextReferenceMap } from '../../configs/useCaseContextReferenc
 import { createContext } from 'react';
 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) => {
+export const useUseCaseContext = (usecase, argumentTypes = UseCaseArgumentTypes.None) => {
     const map = usecaseContextReferenceMap;
     const context = useConstant(() => {
         if (map.has(usecase)) {
@@ -17,12 +16,8 @@ export const useUseCaseContext = (usecase, argumentTypes = UseCaseArgumentTypes.
             });
             return value;
         }
-        switch (true) {
-            case (mode & UseCaseModes.Global) === UseCaseModes.Global:
-            case (argumentTypes & UseCaseArgumentTypes.Entity) === UseCaseArgumentTypes.Entity:
-                break;
-            default:
-                return defaultUseCaseContext;
+        if ((argumentTypes & UseCaseArgumentTypes.Entity) !== UseCaseArgumentTypes.Entity) {
+            return defaultUseCaseContext;
         }
         const ctx = createContext(null);
         map.set(usecase, {

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

@@ -3,7 +3,6 @@ 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 {};
@@ -18,45 +17,18 @@ describe('useUseCaseContext', () => {
     });
     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);
+            return useUseCaseContext(testUseCase, UseCaseArgumentTypes.None);
         });
         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);
+            return useUseCaseContext(testUseCase, UseCaseArgumentTypes.Entity);
         });
         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);

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

@@ -2,5 +2,5 @@ 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;
+import { Reducers } from '@mic-rexjs/usecases';
+export declare const useUseCaseStatuses: <T extends Reducers>(argumentTypes: UseCaseArgumentTypes, mode: UseCaseModes, contextValue: UseCaseContextValue<T> | null) => UseCaseStatuses;

package/es/hooks/useUseCaseStatuses/index.js

@@ -9,11 +9,11 @@ export const useUseCaseStatuses = (argumentTypes, mode, contextValue) => {
         if ((argumentTypes & UseCaseArgumentTypes.Entity) === UseCaseArgumentTypes.Entity) {
             statuses |= UseCaseStatuses.EntityRootEnabled;
         }
-        if (contextValue === null) {
-            statuses |= UseCaseStatuses.RootEnabled;
+        if (contextValue) {
+            statuses |= UseCaseStatuses.ContextEnabled;
         }
         else {
-            statuses |= UseCaseStatuses.ContextEnabled;
+            statuses |= UseCaseStatuses.RootEnabled;
         }
         if (store) {
             statuses |= UseCaseStatuses.EntityEnabled;

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 { RootCoreCollection, ContextualCoreCollection, CoreCollection, PseudoCoreCollection, } from './hooks/useUseCase/types';
+export type { RootCoreCollection, ContextualCoreCollection, CoreCollection } from './hooks/useUseCase/types';
 export type { UseCaseHookOptions } from './hooks/useUseCase/types';
 export type { UseCaseProvider } from './hooks/useProvider/types';
 export type { UseCaseFragmentProps } from './components/UseCaseFragment/types';

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

@@ -1,5 +1,5 @@
 import { UseCaseHookParameters } from '../../hooks/useUseCase/types';
-import { ReducerMap } from '@mic-rexjs/usecases';
+import { Reducers } 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>;
+export declare const fillArguments: <T, TReducers extends Reducers, TUseCaseOptions extends object>(args: UseCaseHookParameters, argumentTypes: UseCaseArgumentTypes) => UseCaseHookFullParameters<T, TReducers, TUseCaseOptions>;

package/es/methods/fillArguments/index.js

@@ -22,15 +22,6 @@ export const fillArguments = (args, argumentTypes) => {
             (arg4 || []),
         ];
     }
-    if (hasMode) {
-        return [
-            null,
-            arg1,
-            arg2,
-            (arg3 || {}),
-            (arg4 || []),
-        ];
-    }
     return [
         null,
         arg1,

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

@@ -1,9 +1,9 @@
 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> = [
+import { EntityReducers, EntityUseCase, Reducers, UseCase } from '@mic-rexjs/usecases';
+export type UseCaseHookFullParameters<T, TReducers extends Reducers, TUseCaseOptions extends object> = [
     entity: T | EntityGetter<T>,
-    usecase: UseCase<TReducers, TUseCaseOptions> | EntityUseCase<T, TReducers & EntityReducerMap<T>, TUseCaseOptions>,
+    usecase: UseCase<TReducers, TUseCaseOptions> | EntityUseCase<T, TReducers & EntityReducers<T>, TUseCaseOptions>,
     mode: UseCaseModes,
     options: TUseCaseOptions | UseCaseHookOptions<T, TUseCaseOptions> | UseCaseHookContextualOptions<T>,
     deps: unknown[]

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

@@ -1,4 +1,4 @@
-import { EntityReducerMap, EntityStore, EntityUseCase } from '@mic-rexjs/usecases';
+import { EntityReducers, EntityStore, EntityUseCase } from '@mic-rexjs/usecases';
 import { UseCaseHookOptions } from '../../hooks/useUseCase/types';
 import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
-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>;
+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>;

package/lib/hooks/useArgumentTypes/index.js

@@ -18,12 +18,9 @@ var useArgumentTypes = exports.useArgumentTypes = function useArgumentTypes(args
     var type2 = (0, _typeof2["default"])(arg2);
     if (type2 === 'function') {
       types |= _UseCaseArgumentTypes.UseCaseArgumentTypes.Entity;
-    }
-    switch ('number') {
-      case type2:
-      case (0, _typeof2["default"])(arg3):
+      if (typeof arg3 === 'number') {
         types |= _UseCaseArgumentTypes.UseCaseArgumentTypes.Mode;
-        break;
+      }
     }
     return types;
   });

package/lib/hooks/useContextualItem/index.js

@@ -7,7 +7,7 @@ exports.useContextualItem = void 0;
 var _ahooks = require("ahooks");
 var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
 var _useMemoizedCall = require("../useMemoizedCall");
-var useContextualItem = exports.useContextualItem = function useContextualItem(statuses, contextItem, createFactory) {
+var useContextualItem = exports.useContextualItem = function useContextualItem(contextItem, statuses, createFactory) {
   var deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
   var create = (0, _useMemoizedCall.useMemoizedCall)(createFactory, deps);
   return (0, _ahooks.useCreation)(function () {

package/lib/hooks/useEntity/index.js

@@ -22,14 +22,13 @@ var useEntity = exports.useEntity = function useEntity(statuses, rootEntity, con
   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 () {
+  var store = (0, _useContextualItem.useContextualItem)(contextStore, statuses, function () {
     if (!entityRootEnabled) {
       return new _usecases.EntityStore(null);
     }
     var stateless = (statuses & _UseCaseStatuses.UseCaseStatuses.StatelessEnabled) === _UseCaseStatuses.UseCaseStatuses.StatelessEnabled;
     return new _usecases.EntityStore(renderingEntity, {
-      onChange: function onChange(_ref) {
-        var newEntity = _ref.newEntity;
+      onChange: function onChange(newEntity) {
         if (stateless) {
           return;
         }
@@ -45,9 +44,7 @@ var useEntity = exports.useEntity = function useEntity(statuses, rootEntity, con
     if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
       return;
     }
-    var onEntityChange = function onEntityChange(e) {
-      var newEntity = e.newEntity,
-        oldEntity = e.oldEntity;
+    var onEntityChange = function onEntityChange(newEntity, oldEntity) {
       var _optionsRef$current = optionsRef.current,
         onChange = _optionsRef$current.onChange,
         watch = _optionsRef$current.watch;
@@ -56,9 +53,9 @@ var useEntity = exports.useEntity = function useEntity(statuses, rootEntity, con
       }
       onChange === null || onChange === void 0 || onChange(newEntity, oldEntity);
     };
-    store.addEventListener('change', onEntityChange);
+    store.watch(onEntityChange);
     return function () {
-      store.removeEventListener('change', onEntityChange);
+      store.unwatch(onEntityChange);
     };
   }, [statuses, store, optionsRef]);
   return (0, _ahooks.useCreation)(function () {

package/lib/hooks/useGlobalUseCase/index.js

@@ -6,6 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.useGlobalUseCase = void 0;
 var _useUseCase = require("../useUseCase");
 var _UseCaseModes = require("../../enums/UseCaseModes");
-var useGlobalUseCase = exports.useGlobalUseCase = function useGlobalUseCase(useCase, options, deps) {
-  return (0, _useUseCase.useUseCase)(useCase, _UseCaseModes.UseCaseModes.Global, options, deps);
+var useGlobalUseCase = exports.useGlobalUseCase = function useGlobalUseCase(entity, useCase, options, deps) {
+  return (0, _useUseCase.useUseCase)(entity, useCase, _UseCaseModes.UseCaseModes.Global, options, deps);
 };

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

@@ -1,26 +1,37 @@
 "use strict";
 
 var _typeof = require("@babel/runtime/helpers/typeof");
-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 useUseCaseModule = _interopRequireWildcard(require("../useUseCase"));
+var _ = require(".");
 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 mathUseCase = function mathUseCase() {
-  return {};
+var numberUseCase = function numberUseCase() {
+  return (0, _usecases.entityUseCase)();
 };
 (0, _globals.describe)('useGlobalUseCase', function () {
-  (0, _globals.describe)('`useGlobalUseCase` should work the same as `GlobalPseudoCoreCollectionHook`', function () {
-    (0, _globals.test)('check `useUseCase` has received correct arguments', function () {
+  (0, _globals.describe)('`useGlobalUseCase` should work the same as `RootCoreCollectionHook`', function () {
+    (0, _globals.test)('should pass `UseCaseModes.Global` to `useUseCase`', function () {
       var useMockedUseCase = _globals.jest.fn();
       _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockImplementation(useMockedUseCase);
       (0, _react.renderHook)(function () {
-        (0, _.useGlobalUseCase)(mathUseCase);
+        (0, _.useGlobalUseCase)(1, numberUseCase);
       });
-      (0, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(mathUseCase, _UseCaseModes.UseCaseModes.Global, void 0, void 0);
+      (0, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(1, numberUseCase, _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), void 0, void 0]);
+    });
   });
 });

package/lib/hooks/useProvider/index.js

@@ -18,11 +18,13 @@ var useProvider = exports.useProvider = function useProvider(statuses, context,
     if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) === _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
       return {
         store: store,
-        reducers: reducers
+        reducers: reducers,
+        statuses: statuses
       };
     }
     return {
-      reducers: reducers
+      reducers: reducers,
+      statuses: statuses
     };
   }, [statuses, entity, store, reducers]);
   var contextValueRef = (0, _ahooks.useLatest)(contextValue);

package/lib/hooks/useUseCase/index.js

@@ -20,8 +20,8 @@ var _UseCaseStatuses = require("../../enums/UseCaseStatuses");
 var _useEntity3 = require("../useEntity");
 var _useContextualItem = require("../useContextualItem");
 var _cacheCalls = require("../../methods/cacheCalls");
-var _useSafeMode = require("../useSafeMode");
 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];
   }
@@ -30,21 +30,21 @@ var useUseCase = exports.useUseCase = function useUseCase() {
   var _fullArguments = (0, _slicedToArray2["default"])(fullArguments, 5),
     unsafeEntity = _fullArguments[0],
     unsafeUsecase = _fullArguments[1],
-    unsafeMode = _fullArguments[2],
+    mode = _fullArguments[2],
     options = _fullArguments[3],
     deps = _fullArguments[4];
   var unkownUsecase = (0, _useConstantFn.useConstantFn)(unsafeUsecase);
   var usecase = unkownUsecase;
   var entityUseCase = unkownUsecase;
-  var isRenderingRef = (0, _useIsRenderingRef.useIsRenderingRef)();
-  var mode = (0, _useSafeMode.useSafeMode)(unsafeMode, argumentTypes);
-  var context = (0, _useUseCaseContext.useUseCaseContext)(unkownUsecase, argumentTypes, mode);
+  var context = (0, _useUseCaseContext.useUseCaseContext)(unkownUsecase, argumentTypes);
   var contextValue = (0, _react.useContext)(context);
   var entityContextValue = contextValue;
   var statuses = (0, _useUseCaseStatuses.useUseCaseStatuses)(argumentTypes, mode, contextValue);
   var _ref = contextValue || {},
     _ref$reducers = _ref.reducers,
-    contextReducers = _ref$reducers === void 0 ? null : _ref$reducers;
+    contextReducers = _ref$reducers === void 0 ? null : _ref$reducers,
+    _ref$statuses = _ref.statuses,
+    contextStatueses = _ref$statuses === void 0 ? _UseCaseStatuses.UseCaseStatuses.None : _ref$statuses;
   var _ref2 = entityContextValue || {},
     _ref2$store = _ref2.store,
     contextStore = _ref2$store === void 0 ? null : _ref2$store;
@@ -52,7 +52,7 @@ var useUseCase = exports.useUseCase = function useUseCase() {
     _useEntity2 = (0, _slicedToArray2["default"])(_useEntity, 2),
     entity = _useEntity2[0],
     store = _useEntity2[1];
-  var reducers = (0, _useContextualItem.useContextualItem)(statuses, contextReducers, function () {
+  var reducers = (0, _useContextualItem.useContextualItem)(contextReducers, statuses, function () {
     if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
       return usecase(options);
     }
@@ -61,13 +61,10 @@ var useUseCase = exports.useUseCase = function useUseCase() {
   }, deps);
   var Provider = (0, _useProvider.useProvider)(statuses, context, store, reducers);
   return (0, _ahooks.useCreation)(function () {
-    if ((statuses & _UseCaseStatuses.UseCaseStatuses.ContextEnabled) !== _UseCaseStatuses.UseCaseStatuses.ContextEnabled) {
+    if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
       return reducers;
     }
     var rootEnabled = (statuses & _UseCaseStatuses.UseCaseStatuses.RootEnabled) === _UseCaseStatuses.UseCaseStatuses.RootEnabled;
-    if ((statuses & _UseCaseStatuses.UseCaseStatuses.EntityEnabled) !== _UseCaseStatuses.UseCaseStatuses.EntityEnabled) {
-      return rootEnabled ? [reducers, Provider] : reducers;
-    }
     var cachedReducers = (0, _cacheCalls.cacheCalls)(reducers, {
       onShouldCache: function onShouldCache() {
         return isRenderingRef.current;
@@ -76,6 +73,9 @@ var useUseCase = exports.useUseCase = function useUseCase() {
     if (rootEnabled) {
       return [entity, cachedReducers, Provider];
     }
+    if ((contextStatueses & _UseCaseStatuses.UseCaseStatuses.GlobalEnabled) === _UseCaseStatuses.UseCaseStatuses.GlobalEnabled) {
+      return cachedReducers;
+    }
     return [entity, cachedReducers];
-  }, [statuses, entity, reducers, Provider, isRenderingRef]);
+  }, [statuses, contextStatueses, entity, reducers, Provider, isRenderingRef]);
 };