@mic-rexjs/usecases-react 1.8.0 → 2.0.2

package/es/hooks/useUseCaseContext/index.js

@@ -1,17 +1,46 @@
 import { useConstant } from '../useConstant';
-import { usecaseContextMap } from '../../configs/usecaseContextMap';
+import { usecaseContextReferenceMap } from '../../configs/useCaseContextReferenceMap';
 import { createContext } from 'react';
+import { useUnmount } from 'ahooks';
 export const useUseCaseContext = (usecase, defaultContext) => {
-    return useConstant(() => {
-        const map = usecaseContextMap;
+    const map = usecaseContextReferenceMap;
+    const context = useConstant(() => {
         if (map.has(usecase)) {
-            return map.get(usecase);
+            const reference = map.get(usecase);
+            const { value, times } = reference;
+            map.set(usecase, {
+                value,
+                times: times + 1,
+            });
+            return value;
         }
         if (defaultContext) {
             return defaultContext;
         }
-        const ctx = createContext({});
-        map.set(usecase, ctx);
+        const ctx = createContext(null);
+        map.set(usecase, {
+            value: ctx,
+            times: 1,
+        });
         return ctx;
     });
+    useUnmount(() => {
+        if (!map.has(usecase)) {
+            return;
+        }
+        const reference = map.get(usecase);
+        const { value, times } = reference;
+        if (context !== value) {
+            return;
+        }
+        if (times === 1) {
+            map.delete(usecase);
+            return;
+        }
+        map.set(usecase, {
+            value,
+            times: times - 1,
+        });
+    });
+    return context;
 };

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

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

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

@@ -0,0 +1,60 @@
+import { describe, expect, test } from '@jest/globals';
+import { renderHook } from '@testing-library/react';
+import { useUseCaseContext } from '.';
+import { objectUseCase } from '@mic-rexjs/usecases';
+import { defaultUseCaseContext } from '../../configs/defaultUseCaseContext';
+import { usecaseContextReferenceMap } from '../../configs/useCaseContextReferenceMap';
+const testUseCase = () => {
+    return objectUseCase();
+};
+describe('useUseCaseContext', () => {
+    test('should return the default context if map has not save a usecase and provide a default context', () => {
+        const defaultContext = defaultUseCaseContext;
+        const { result } = renderHook(() => {
+            return useUseCaseContext(testUseCase, defaultContext);
+        });
+        const { current } = result;
+        expect(current).toBe(defaultUseCaseContext);
+    });
+    test('should return a new context if map has not save a usecase and does not provide a default context', () => {
+        const { result } = renderHook(() => {
+            return useUseCaseContext(testUseCase, null);
+        });
+        const { current } = result;
+        expect(typeof current).toBe('object');
+    });
+    test.each([void 0, null, defaultUseCaseContext])('should return the existing context if map has save a usecase already', (defaultContext) => {
+        const { result } = renderHook(() => {
+            return useUseCaseContext(testUseCase) === useUseCaseContext(testUseCase, defaultContext);
+        });
+        const { current: isSame } = result;
+        expect(isSame).toBe(true);
+    });
+    test('check context reference times when mount/unmount a usecase', () => {
+        const { unmount: unmount1 } = renderHook(() => {
+            useUseCaseContext(testUseCase);
+        });
+        const { times: times1 } = usecaseContextReferenceMap.get(testUseCase);
+        const { unmount: unmount2, rerender: rerender2 } = renderHook(() => {
+            useUseCaseContext(testUseCase);
+            useUseCaseContext(testUseCase);
+        });
+        const { times: times2 } = usecaseContextReferenceMap.get(testUseCase);
+        expect(times1).toBe(1);
+        expect(times2).toBe(3);
+        unmount1();
+        const { times: times3 } = usecaseContextReferenceMap.get(testUseCase);
+        expect(times3).toBe(2);
+        unmount2();
+        const hasSaved = usecaseContextReferenceMap.has(testUseCase);
+        expect(hasSaved).toBe(false);
+    });
+    test('context reference times should not change when rerender hooks', () => {
+        const { rerender } = renderHook(() => {
+            useUseCaseContext(testUseCase);
+        });
+        rerender();
+        const { times } = usecaseContextReferenceMap.get(testUseCase);
+        expect(times).toBe(1);
+    });
+});

package/es/index.d.ts

@@ -1,5 +1,7 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
+export { useGlobalUseCase } from './hooks/useGlobalUseCase';
+export { useStatelessUseCase } from './hooks/useStatelessUseCase';
 export type { CoreCollection } from './hooks/useUseCase/types';
 export type { UseCaseHookOptions } from './hooks/useUseCase/types';
 export type { UseCaseProvider } from './hooks/useProvider/types';

package/es/index.js

@@ -1,2 +1,4 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
+export { useGlobalUseCase } from './hooks/useGlobalUseCase';
+export { useStatelessUseCase } from './hooks/useStatelessUseCase';

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

@@ -1,2 +1,3 @@
+import { UseCaseModes } from '../../enums/UseCaseModes';
 import { EntityGetter } from '../../hooks/useUseCase/types';
-export declare const getRootEntity: <T>(entityState: T, entityArg: T | EntityGetter<T>, stateless?: boolean) => T;
+export declare const getRootEntity: <T>(entityState: T, unsafeEntity: T | EntityGetter<T>, mode: UseCaseModes) => T;

package/es/methods/getRootEntity/index.js

@@ -1,9 +1,10 @@
-export const getRootEntity = (entityState, entityArg, stateless) => {
-    if (!stateless) {
+import { UseCaseModes } from '../../enums/UseCaseModes';
+export const getRootEntity = (entityState, unsafeEntity, mode) => {
+    if ((mode & UseCaseModes.Stateless) !== UseCaseModes.Stateless) {
         return entityState;
     }
-    if (typeof entityArg === 'function') {
-        return entityArg();
+    if (typeof unsafeEntity === 'function') {
+        return unsafeEntity();
     }
-    return entityArg;
+    return unsafeEntity;
 };

package/es/methods/initEntityReducers/index.js

@@ -1,7 +1,6 @@
-import { entityReducerUseCase } from '@mic-rexjs/usecases';
+import { createEntityReducers } from '@mic-rexjs/usecases';
 export const initEntityReducers = (entity, usecase, options, onEntityChange) => {
-    const { createEntityReducers } = entityReducerUseCase();
-    const { stateless, watch, onChange, options: usecaseOptions, ...restUseCaseOptions } = options;
+    const { watch, onChange, options: usecaseOptions, ...restUseCaseOptions } = options;
     return createEntityReducers(entity, usecase, {
         ...restUseCaseOptions,
         ...usecaseOptions,

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

@@ -0,0 +1,3 @@
+import { UseCaseHookMaxParameters, UseCaseHookParameters } from '../../hooks/useUseCase/types';
+import { EntityReducers, Reducers } from '@mic-rexjs/usecases';
+export declare const toMaxArguments: <T, TReducers extends Reducers, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object>([arg1, arg2, arg3, arg4, arg5]: UseCaseHookParameters<T, TReducers, TEntityReducers, TUseCaseOptions>) => UseCaseHookMaxParameters<T, TReducers, TEntityReducers, TUseCaseOptions>;

package/es/methods/toMaxArguments/index.js

@@ -0,0 +1,28 @@
+import { UseCaseModes } from '../../enums/UseCaseModes';
+export const toMaxArguments = ([arg1, arg2, arg3, arg4, arg5]) => {
+    if (typeof arg2 !== 'function') {
+        return [
+            null,
+            arg1,
+            UseCaseModes.Normal,
+            arg2 || {},
+            (arg3 || []),
+        ];
+    }
+    if (typeof arg3 === 'number') {
+        return [
+            arg1,
+            arg2,
+            arg3,
+            (arg4 || {}),
+            arg5 || [],
+        ];
+    }
+    return [
+        arg1,
+        arg2,
+        UseCaseModes.Normal,
+        (arg3 || {}),
+        (arg4 || []),
+    ];
+};

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

@@ -1,3 +1,2 @@
-import { OptionsRefCollection } from '../../hooks/useOptionsRefCollection/types';
-import { UseCaseHookOptions } from '../../hooks/useUseCase/types';
-export declare const triggerCallbacks: <T, TUseCaseOptions extends object, TOptions extends UseCaseHookOptions<T, TUseCaseOptions> = UseCaseHookOptions<T, TUseCaseOptions>>(optionsRefCollection: OptionsRefCollection<TOptions>, newEntity: T, oldEntity: T) => void;
+import { ChangeCallback } from '../../configs/defaultUseCaseContext/types';
+export declare const triggerCallbacks: <T>(changeCallbackCollection: ChangeCallback<T>[], newEntity: T, oldEntity: T) => void;

package/es/methods/triggerCallbacks/index.js

@@ -1,14 +1,5 @@
-import { triggerWatchers } from '../triggerWatchers';
-export const triggerCallbacks = (optionsRefCollection, newEntity, oldEntity) => {
-    for (let { length: i } = optionsRefCollection; i > 0; i--) {
-        const { current: options } = optionsRefCollection[i - 1];
-        if (!options) {
-            continue;
-        }
-        const { onChange, watch } = options;
-        if (watch) {
-            triggerWatchers(watch, newEntity, oldEntity);
-        }
-        onChange?.(newEntity, oldEntity);
+export const triggerCallbacks = (changeCallbackCollection, newEntity, oldEntity) => {
+    for (let { length: i } = changeCallbackCollection; i > 0; i--) {
+        changeCallbackCollection[i - 1](newEntity, oldEntity);
     }
 };

package/lib/configs/defaultUseCaseContext/index.js

@@ -5,5 +5,5 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.defaultUseCaseContext = void 0;
 var _react = require("react");
-var defaultUseCaseContext = (0, _react.createContext)({});
+var defaultUseCaseContext = (0, _react.createContext)(null);
 exports.defaultUseCaseContext = defaultUseCaseContext;

package/lib/configs/useCaseContextReferenceMap/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usecaseContextReferenceMap = void 0;
+var usecaseContextReferenceMap = new Map();
+exports.usecaseContextReferenceMap = usecaseContextReferenceMap;

package/lib/enums/UseCaseModes/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UseCaseModes = void 0;
+var UseCaseModes;
+exports.UseCaseModes = UseCaseModes;
+(function (UseCaseModes) {
+  UseCaseModes[UseCaseModes["Normal"] = 2] = "Normal";
+  UseCaseModes[UseCaseModes["Stateless"] = 4] = "Stateless";
+  UseCaseModes[UseCaseModes["Global"] = 8] = "Global";
+  UseCaseModes[UseCaseModes["StatelessGlobal"] = 12] = "StatelessGlobal";
+})(UseCaseModes || (exports.UseCaseModes = UseCaseModes = {}));

package/lib/hooks/useChangeCallbackCollection/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useChangeCallbackCollection = void 0;
+var _ahooks = require("ahooks");
+var _removeItem = require("../../methods/removeItem");
+var _triggerWatchers = require("../../methods/triggerWatchers");
+var useChangeCallbackCollection = function useChangeCallbackCollection(isRoot, contextCollection, options) {
+  var changeCallbackCollection = (0, _ahooks.useCreation)(function () {
+    if (isRoot) {
+      return [];
+    }
+    return contextCollection;
+  }, [contextCollection, isRoot]);
+  var onEntityChange = (0, _ahooks.useMemoizedFn)(function (newEntity, oldEntity) {
+    var onChange = options.onChange,
+      watch = options.watch;
+    if (watch) {
+      (0, _triggerWatchers.triggerWatchers)(watch, newEntity, oldEntity);
+    }
+    onChange === null || onChange === void 0 ? void 0 : onChange(newEntity, oldEntity);
+  });
+  var prevChangeCallbackCollection = (0, _ahooks.usePrevious)(changeCallbackCollection);
+  (0, _ahooks.useCreation)(function () {
+    if (prevChangeCallbackCollection) {
+      (0, _removeItem.removeItem)(prevChangeCallbackCollection, onEntityChange);
+    }
+    changeCallbackCollection.push(onEntityChange);
+  }, [onEntityChange, changeCallbackCollection, prevChangeCallbackCollection]);
+  (0, _ahooks.useUnmount)(function () {
+    (0, _removeItem.removeItem)(changeCallbackCollection, onEntityChange);
+  });
+  return changeCallbackCollection;
+};
+exports.useChangeCallbackCollection = useChangeCallbackCollection;

package/lib/hooks/useGlobalUseCase/index.js

@@ -0,0 +1,25 @@
+"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];
+};
+exports.useGlobalUseCase = useGlobalUseCase;

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

@@ -0,0 +1,78 @@
+"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)();
+};
+(0, _globals.describe)('useGlobalUseCase', function () {
+  (0, _globals.describe)('`useGlobalUseCase` should work the same as `RootCoreCollectionHook`', 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, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(1, numberUseCase, _UseCaseModes.UseCaseModes.Global);
+      _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/useProvider/index.js

@@ -1,34 +1,40 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useProvider = void 0;
-var _react = _interopRequireDefault(require("react"));
-var _useConstant = require("../useConstant");
+var _react = _interopRequireWildcard(require("react"));
 var _ahooks = require("ahooks");
-var useProvider = function useProvider(context, entity, reducers, optionsRefCollection) {
-  var contextValue = (0, _ahooks.useCreation)(function () {
-    return {
-      entity: entity,
-      reducers: reducers,
-      optionsRefCollection: optionsRefCollection
-    };
-  }, [entity, reducers, optionsRefCollection]);
-  var contextValueRef = (0, _ahooks.useLatest)(contextValue);
-  return (0, _useConstant.useConstant)(function () {
-    return 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: contextValueRef.current
-      }, withProviders.reduceRight(function (currentChildren, withProvider) {
-        return _react["default"].createElement(withProvider, {}, currentChildren);
-      }, children));
-    };
+var _UseCaseModes = require("../../enums/UseCaseModes");
+var _useCompareDeps = require("../useCompareDeps");
+var _useConstantFn = require("../useConstantFn");
+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);
+  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
+    }, withProviders.reduceRight(function (currentChildren, withProvider) {
+      return _react["default"].createElement(withProvider, {}, currentChildren);
+    }, children));
   });
 };
 exports.useProvider = useProvider;

package/lib/hooks/useStatelessUseCase/index.js

@@ -0,0 +1,22 @@
+"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;
+};
+exports.useStatelessUseCase = useStatelessUseCase;

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

@@ -0,0 +1,78 @@
+"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); }
+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)();
+};
+(0, _globals.describe)('useStatelessUseCase', function () {
+  (0, _globals.describe)('`useStatelessUseCase` should work the same as `RootCoreCollectionHook`', function () {
+    (0, _globals.test)('should pass `UseCaseModes.Stateless` to `useUseCase`', function () {
+      var useMockedUseCase = _globals.jest.fn();
+      _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockImplementation(useMockedUseCase);
+      (0, _react.renderHook)(function () {
+        (0, _.useStatelessUseCase)(1, numberUseCase);
+      });
+      (0, _globals.expect)(useMockedUseCase).toHaveBeenCalledWith(1, numberUseCase, _UseCaseModes.UseCaseModes.Stateless);
+      _globals.jest.spyOn(useUseCaseModule, 'useUseCase').mockRestore();
+    });
+    (0, _globals.test)('should should return `CoreCollection` with Provider', function () {
+      var _renderHook = (0, _react.renderHook)(function () {
+          return (0, _.useStatelessUseCase)(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)('`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]);
+    });
+  });
+});

package/lib/hooks/useStatelessUseCase/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});