@mic-rexjs/usecases-react 1.3.32

package/README.md

@@ -0,0 +1,187 @@
+## Description
+React-based solution for use usecases of Clean Architecture.
+
+## Install
+```bash
+$ npm install --save @mic-rexjs/usecase-react
+# -
+$ yarn add --dev @mic-rexjs/usecase-react
+```
+
+## Links
+- [Usage with Non-Entity Mode](#usage-with-non-entity-mode)
+- [Useage with Entity Mode](#useage-with-entity-mode)
+- [Test Demos](#test-demos)
+
+## Usage with Non-Entity Mode
+```tsx
+// a.ts
+import { Reducers } from '@mic-rexjs/usecases';
+
+type MathReducers = Reducers<{
+  add(value1: number, value2: number): number;
+
+  subtraction(value1: number, value2: number): number;
+}>;
+
+const mathUseCase = (): MathReducers => {
+  const add = (value1: number, value2: number): number => {
+    return value1 + value2;
+  };
+
+  const subtraction = (value1: number, value2: number): number => {
+    return value1 - value2;
+  };
+
+  return { add, subtraction };
+};
+
+// b.tsx
+const MyComponent = (): React.ReactElement => {
+	const { add, subtraction } = useUseCase(mathUseCase);
+
+	// you can use these reducers any where, and they will be never updated.
+	add(1, 2);
+	subtraction(5, 3);
+
+	// ...
+};
+```
+
+## Useage with Entity Mode
+```tsx
+// a.ts
+import {
+	objectUseCase,
+	ObjectReducers,
+	EntityGenerator,
+	EntityReducers
+} from '@mic-rexjs/usecases';
+
+interface File {
+  path: string;
+  content: string;
+}
+
+interface FileUseCaseOptions {
+  maxContentLength?: number;
+}
+
+// All reducers should provide the first argument with an entity type T, such as `file: T`.
+type FileReducers<T extends File> = EntityReducers<
+  T,
+  {
+    writeFile(entity: T, content: string): EntityGenerator<T, string>;
+    isTxt(entity: T): boolean;
+  },
+  // optional to extends an existed reducers
+  ObjectReducers<T>
+>;
+
+const fileUseCase = <T extends File>({ maxContentLength = 2000 }: FileUseCaseOptions = {}): FileReducers<T> => {
+  /**
+   * if you have not extends an existed reducers,
+   * you should call `entityUseCase` at here,
+   * such as `const entityReducers = entityUseCase<T>()`.
+   */
+  const objectReducers = objectUseCase<T>();
+
+  const writeFile = function* (entity: T, content: string): EntityGenerator<T, string> {
+    const { content: prevContent } = entity;
+    const newContent = prevContent + content;
+
+    if (newContent.length > maxContentLength) {
+      throw 'max length error';
+    }
+
+    // set new entity by yield expression
+    yield {
+      ...entity,
+      content: newContent,
+    };
+
+    // return the new content
+    return newContent;
+  };
+
+  const isTxt = (entity: T): boolean => {
+    const { path } = entity;
+
+    return path.endsWith('.txt');
+  };
+
+  return { ...objectReducers, writeFile, isTxt };
+};
+
+// b.tsx
+import { useUseCase } from '@mic-rexjs/usecase-react';
+import ReactDOM from 'react-dom';
+
+const ParentComponent = ({ children }: React.PropsWithChildren): React.ReactElement => {
+  // Pass a default entity to initialize usecase, this usecase must be unique, just like `react context`.
+  const [entity, reducers, Provider] = useUseCase({ path: '', content: '' }, fileUseCase);
+  const { path } = entity;
+  const { writeFile } = reducers;
+
+  const onClick = (): void => {
+    // update entity
+    writeFile('hello world');
+  };
+
+  return (
+    // There's no need `value` property
+    <Provider>
+      <div>
+        <header>file path is: {path}</header>
+        <main>{children}</main>
+        <footer>
+          <button onClick={onClick}>write file</button>
+        </footer>
+      </div>
+    </Provider>
+  );
+};
+
+const ChildComponent = (): React.ReactElement => {
+  /**
+   * use a usecase which has initialzed in parent component,
+   * just like `useContext()`, but the parameter is a usecase.
+   */
+  const [entity, reducers] = useUseCase(fileUseCase);
+  const { content } = entity;
+  const { isTxt, writeFile } = reducers;
+
+  const onClick = (): void => {
+    // also, you can update entity at child component
+    writeFile('hello China');
+  };
+
+	/**
+	 * reducers will be updated with entity change,
+	 * so, you can add some reducers to deps.
+	 */
+	const ext = useMemo((): string => {
+		return isTxt() ? '.txt' : '.js';
+	}, [isTxt]);
+
+  return (
+    <div>
+      <header>ext: {ext}</header>
+      <main>{content}</main>
+      <footer>
+        <button onClick={onClick}>write file</button>
+      </footer>
+    </div>
+  );
+};
+
+ReactDOM.render(
+  <ParentComponent>
+    <ChildComponent />
+  </ParentComponent>,
+  document.body
+);
+```
+
+## Test Demos
+- [useUseCase](https://github.com/mic-rexjs/usecase-react/blob/main/src/entityUseCase/index.test.ts)

package/dist/index.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see index.min.js.LICENSE.txt */
+!function(e,r){if("object"==typeof exports&&"object"==typeof module)module.exports=r(require("react"),require("ahooks"),require("@mic-rexjs/usecases"));else if("function"==typeof define&&define.amd)define(["react","ahooks","@mic-rexjs/usecases"],r);else{var t="object"==typeof exports?r(require("react"),require("ahooks"),require("@mic-rexjs/usecases")):r(e.react,e.ahooks,e["@mic-rexjs/usecases"]);for(var n in t)("object"==typeof exports?exports:e)[n]=t[n]}}(this,((e,r,t)=>(()=>{"use strict";var n={251:(e,r,t)=>{var n=t(156),o=Symbol.for("react.element"),u=(Symbol.for("react.fragment"),Object.prototype.hasOwnProperty),i=n.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,a={key:!0,ref:!0,__self:!0,__source:!0};r.jsx=function(e,r,t){var n,c={},f=null,l=null;for(n in void 0!==t&&(f=""+t),void 0!==r.key&&(f=""+r.key),void 0!==r.ref&&(l=r.ref),r)u.call(r,n)&&!a.hasOwnProperty(n)&&(c[n]=r[n]);if(e&&e.defaultProps)for(n in r=e.defaultProps)void 0===c[n]&&(c[n]=r[n]);return{$$typeof:o,type:e,key:f,ref:l,props:c,_owner:i.current}}},893:(e,r,t)=>{e.exports=t(251)},112:e=>{e.exports=t},749:e=>{e.exports=r},156:r=>{r.exports=e}},o={};function u(e){var r=o[e];if(void 0!==r)return r.exports;var t=o[e]={exports:{}};return n[e](t,t.exports,u),t.exports}u.n=e=>{var r=e&&e.__esModule?()=>e.default:()=>e;return u.d(r,{a:r}),r},u.d=(e,r)=>{for(var t in r)u.o(r,t)&&!u.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},u.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),u.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var i={};return(()=>{u.r(i),u.d(i,{UseCaseFragment:()=>g,useUseCase:()=>O});var e=u(893),r=u(156),t=u.n(r);function n(e,r){(null==r||r>e.length)&&(r=e.length);for(var t=0,n=new Array(r);t<r;t++)n[t]=e[t];return n}function o(e,r){if(e){if("string"==typeof e)return n(e,r);var t=Object.prototype.toString.call(e).slice(8,-1);return"Object"===t&&e.constructor&&(t=e.constructor.name),"Map"===t||"Set"===t?Array.from(e):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?n(e,r):void 0}}function a(e){return a="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},a(e)}function c(e,r,t){return(r=function(e){var r=function(e,r){if("object"!==a(e)||null===e)return e;var t=e[Symbol.toPrimitive];if(void 0!==t){var n=t.call(e,"string");if("object"!==a(n))return n;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(e)}(e);return"symbol"===a(r)?r:String(r)}(r))in e?Object.defineProperty(e,r,{value:t,enumerable:!0,configurable:!0,writable:!0}):e[r]=t,e}function f(e,r){return function(e){if(Array.isArray(e))return e}(e)||function(e,r){var t=null==e?null:"undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(null!=t){var n,o,u,i,a=[],c=!0,f=!1;try{if(u=(t=t.call(e)).next,0===r){if(Object(t)!==t)return;c=!1}else for(;!(c=(n=u.call(t)).done)&&(a.push(n.value),a.length!==r);c=!0);}catch(e){f=!0,o=e}finally{try{if(!c&&null!=t.return&&(i=t.return(),Object(i)!==i))return}finally{if(f)throw o}}return a}}(e,r)||o(e,r)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}var l=u(749),s=(0,r.createContext)(null),y=new Map,p=function(e,r,t){for(var n=0,o=Object.entries(e);n<o.length;n++){var u=f(o[n],2),i=u[0],a=u[1];(null==r?void 0:r[i])!==(null==t?void 0:t[i])&&a(r,t)}};function b(e,r){(null==r||r>e.length)&&(r=e.length);for(var t=0,n=new Array(r);t<r;t++)n[t]=e[t];return n}var v=u(112),m=["stateless","watch","onChange","options"];function d(e,r){var t=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);r&&(n=n.filter((function(r){return Object.getOwnPropertyDescriptor(e,r).enumerable}))),t.push.apply(t,n)}return t}function h(e){for(var r=1;r<arguments.length;r++){var t=null!=arguments[r]?arguments[r]:{};r%2?d(Object(t),!0).forEach((function(r){c(e,r,t[r])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(t)):d(Object(t)).forEach((function(r){Object.defineProperty(e,r,Object.getOwnPropertyDescriptor(t,r))}))}return e}var O=function(e,u,i,a){var c,d=f((0,r.useState)("function"==typeof u),1)[0],O=f((0,r.useState)(d?e:null),2),g=O[0],j=O[1],S=(d?i:u)||{},w=S.stateless,x=(S.watch,S.onChange,S.options),P=function(e,r){if(null==e)return{};var t,n,o=function(e,r){if(null==e)return{};var t,n,o={},u=Object.keys(e);for(n=0;n<u.length;n++)t=u[n],r.indexOf(t)>=0||(o[t]=e[t]);return o}(e,r);if(Object.getOwnPropertySymbols){var u=Object.getOwnPropertySymbols(e);for(n=0;n<u.length;n++)t=u[n],r.indexOf(t)>=0||Object.prototype.propertyIsEnumerable.call(e,t)&&(o[t]=e[t])}return o}(S,m),_=(0,r.useRef)([]),C=(d?a:i)||[],A=f((0,r.useState)((function(){return d?u:e})),1)[0],E=f((0,r.useState)((function(){var e=y,t=A;if(e.has(t))return e.get(t);if(!d)return s;var n=(0,r.createContext)(null);return e.set(t,n),n})),1)[0],M=f((0,r.useContext)(E)||[],3),I=M[0],k=M[1],T=M[2],R=(0,r.useMemo)((function(){return d?w?"function"!=typeof e?e:e():g:I}),[d,I,w,g,e]),U=(0,l.useMemoizedFn)((function(){var e=h(h({},P),x);return d?(0,(0,v.entityReducerUseCase)().createEntityReducers)(R,A,h(h({},e),{},{onChange:function(e,r){d&&!w&&j(e),function(e,r,t){var n,o=function(e,r){var t="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!t){if(Array.isArray(e)||(t=function(e,r){if(e){if("string"==typeof e)return b(e,r);var t=Object.prototype.toString.call(e).slice(8,-1);return"Object"===t&&e.constructor&&(t=e.constructor.name),"Map"===t||"Set"===t?Array.from(e):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?b(e,r):void 0}}(e))||r&&e&&"number"==typeof e.length){t&&(e=t);var n=0,o=function(){};return{s:o,n:function(){return n>=e.length?{done:!0}:{done:!1,value:e[n++]}},e:function(e){throw e},f:o}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var u,i=!0,a=!1;return{s:function(){t=t.call(e)},n:function(){var e=t.next();return i=e.done,e},e:function(e){a=!0,u=e},f:function(){try{i||null==t.return||t.return()}finally{if(a)throw u}}}}(e);try{for(o.s();!(n=o.n()).done;){var u=(0,n.value)(),i=u.onChange,a=u.watch;null==i||i(r,t),a&&p(a,r,t)}}catch(e){o.e(e)}finally{o.f()}}(_.current,e,r)},onGenerate:function(e,r){return r}})):k||A(e)})),q=r.useMemo.call(null,U,[R,U].concat(function(e){if(Array.isArray(e))return n(e)}(c=C)||function(e){if("undefined"!=typeof Symbol&&null!=e[Symbol.iterator]||null!=e["@@iterator"])return Array.from(e)}(c)||o(c)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}())),D=(0,r.useMemo)((function(){return!d&&T?T:(e=_.current,{addOptionsGetter:function(r){e.unshift(r)},removeOptionsGetter:function(r){var t=e.indexOf(r);-1!==t&&e.splice(t,1)}});var e}),[d,T]),F=(0,r.useMemo)((function(){return[R,q,D]}),[R,q,D]),G=(0,l.useLatest)(F),L=f((0,r.useState)((function(){return function(e){var r=e.children,n=E.Provider;return t().createElement(n,{value:G.current},r)}})),1)[0],$=(0,r.useMemo)((function(){return d?[R,q,L]:[R,q]}),[R,q,d,L]),N=(0,r.useMemo)((function(){return E===s?q:$}),[E,q,$]);return function(e,r){var t=r.addOptionsGetter,n=r.removeOptionsGetter,o=(0,l.usePrevious)(n),u=(0,l.useMemoizedFn)((function(){return e}));(0,l.useCreation)((function(){null==o||o(u),t(u)}),[t,o,u]),(0,l.useUnmount)((function(){n(u)}))}(S,D),N},g=function(t){var n=t.usecase,o=t.watch,u=t.onChange;return O(n,{watch:o,onChange:u}),(0,e.jsx)(r.Fragment,{})}})(),i})()));

package/dist/index.min.js.LICENSE.txt

@@ -0,0 +1,9 @@
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

package/es/components/UseCaseFragment/index.d.ts

@@ -0,0 +1,3 @@
+import { UseCaseFragmentProps } from './types';
+import { EntityReducers } from '@mic-rexjs/usecases';
+export declare const UseCaseFragment: <T, TReducers extends EntityReducers<T>>({ usecase, watch, onChange, }: UseCaseFragmentProps<T, TReducers>) => React.ReactElement;

package/es/components/UseCaseFragment/index.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment } from 'react';
+import { useUseCase } from '../../hooks/useUseCase';
+export const UseCaseFragment = ({ usecase, watch, onChange, }) => {
+    void useUseCase(usecase, { watch, onChange });
+    return _jsx(Fragment, {});
+};

package/es/components/UseCaseFragment/types.d.ts

@@ -0,0 +1,7 @@
+import { EntityReducers, EntityUseCase } from '@mic-rexjs/usecases';
+import { EntityWatchMap } from '../../hooks/useUseCase/types';
+export interface UseCaseFragmentProps<T, TReducers extends EntityReducers<T>> {
+    usecase: EntityUseCase<T, TReducers & EntityReducers<T>>;
+    watch?: EntityWatchMap<T>;
+    onChange?(prevEntity: T, nextEntity: T): void;
+}

package/es/components/UseCaseFragment/types.js

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

package/es/configs/defaultUseCaseContext/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const defaultUseCaseContext: import("react").Context<null>;

package/es/configs/defaultUseCaseContext/index.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const defaultUseCaseContext = createContext(null);

package/es/configs/usecaseContextMap/index.d.ts

@@ -0,0 +1,3 @@
+import { EntityReducers } from '@mic-rexjs/usecases';
+import { UseCaseContextMap } from './types';
+export declare const usecaseContextMap: UseCaseContextMap<unknown, EntityReducers<unknown>>;

package/es/configs/usecaseContextMap/index.js

@@ -0,0 +1 @@
+export const usecaseContextMap = new Map();

package/es/configs/usecaseContextMap/types.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { OptionsGetterCollectionReducers } from '../../core/usecases/optionsGetterCellectionUseCase/types';
+import { AsyncEntityGenerator, EntityGenerator, EntityReducers, EntityUseCase } from '@mic-rexjs/usecases';
+export type ContextualEntityReducer<T> = T extends (entity: infer TEntity, ...args: infer TArgs) => infer TReturn ? (...args: TArgs) => TReturn extends AsyncEntityGenerator<TEntity, infer TResult> ? Promise<TResult> : TReturn extends EntityGenerator<TEntity, infer TResult> ? TResult : TReturn : never;
+export type ContextualEntityReducers<T> = {
+    [K in keyof T]: ContextualEntityReducer<T[K]>;
+};
+export type UseCaseContext<T, TReducers> = [entity: T, reducers: ContextualEntityReducers<TReducers>];
+export type UseCaseContextWithCollectionReducers<T, TReducers, TOptions> = [
+    ...context: UseCaseContext<T, TReducers>,
+    collectionReducers: OptionsGetterCollectionReducers<TOptions>
+];
+export interface UseCaseProvider extends React.FC<React.PropsWithChildren> {
+}
+export type UseCaseContextWithProvider<T, TReducers> = [
+    ...args: UseCaseContext<T, TReducers>,
+    Provider: UseCaseProvider
+];
+export interface UseCaseContextMap<T, TReducers extends EntityReducers<T>, TOptions = object> extends Map<EntityUseCase<T, TReducers>, React.Context<UseCaseContextWithCollectionReducers<T, TReducers, TOptions> | null>> {
+}

package/es/configs/usecaseContextMap/types.js

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

package/es/core/usecases/optionsGetterCellectionUseCase/index.d.ts

@@ -0,0 +1,2 @@
+import { OptionsGetter, OptionsGetterCollectionReducers } from './types';
+export declare const optionsGetterCollectionUseCase: <T>(collection: OptionsGetter<T>[]) => OptionsGetterCollectionReducers<T>;

package/es/core/usecases/optionsGetterCellectionUseCase/index.js

@@ -0,0 +1,13 @@
+export const optionsGetterCollectionUseCase = (collection) => {
+    const addOptionsGetter = (getter) => {
+        collection.unshift(getter);
+    };
+    const removeOptionsGetter = (getter) => {
+        const index = collection.indexOf(getter);
+        if (index === -1) {
+            return;
+        }
+        collection.splice(index, 1);
+    };
+    return { addOptionsGetter, removeOptionsGetter };
+};

package/es/core/usecases/optionsGetterCellectionUseCase/types.d.ts

@@ -0,0 +1,8 @@
+import { Reducers } from '@mic-rexjs/usecases';
+export interface OptionsGetter<T> {
+    (): T;
+}
+export type OptionsGetterCollectionReducers<T> = Reducers<{
+    addOptionsGetter(getter: OptionsGetter<T>): void;
+    removeOptionsGetter(getter: OptionsGetter<T>): void;
+}>;

package/es/core/usecases/optionsGetterCellectionUseCase/types.js

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

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

@@ -0,0 +1,3 @@
+import { UseCaseHookOptions } from '../useUseCase/types';
+import { OptionsGetterCollectionReducers } from '../../core/usecases/optionsGetterCellectionUseCase/types';
+export declare const useOptionsTransfer: <T, TOptions extends object>(options: UseCaseHookOptions<T, TOptions>, optionsGetterListReducers: OptionsGetterCollectionReducers<UseCaseHookOptions<T, TOptions>>) => void;

package/es/hooks/useOptionsTransfer/index.js

@@ -0,0 +1,15 @@
+import { useCreation, useMemoizedFn, usePrevious, useUnmount } from 'ahooks';
+export const useOptionsTransfer = (options, optionsGetterListReducers) => {
+    const { addOptionsGetter, removeOptionsGetter } = optionsGetterListReducers;
+    const prevRemoveOptionsGetter = usePrevious(removeOptionsGetter);
+    const getOptions = useMemoizedFn(() => {
+        return options;
+    });
+    useCreation(() => {
+        prevRemoveOptionsGetter?.(getOptions);
+        addOptionsGetter(getOptions);
+    }, [addOptionsGetter, prevRemoveOptionsGetter, getOptions]);
+    useUnmount(() => {
+        removeOptionsGetter(getOptions);
+    });
+};

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

@@ -0,0 +1,2 @@
+import { UseCaseHook } from './types';
+export declare const useUseCase: UseCaseHook;

package/es/hooks/useUseCase/index.js

@@ -0,0 +1,99 @@
+import { useLatest, useMemoizedFn } from 'ahooks';
+import React, { createContext, useContext, useMemo, useRef, useState } from 'react';
+import { defaultUseCaseContext } from '../../configs/defaultUseCaseContext';
+import { usecaseContextMap } from '../../configs/usecaseContextMap';
+import { optionsGetterCollectionUseCase } from '../../core/usecases/optionsGetterCellectionUseCase';
+import { triggerCallbacks } from './methods/triggerCallbacks';
+import { useOptionsTransfer } from '../useOptionsTransfer';
+import { entityReducerUseCase } from '@mic-rexjs/usecases';
+export const useUseCase = ((arg1, arg2, arg3, arg4) => {
+    const [hasDefaultEntity] = useState(typeof arg2 === 'function');
+    const [entityState, setEntityState] = useState(hasDefaultEntity ? arg1 : null);
+    const options = (hasDefaultEntity ? arg3 : arg2) || {};
+    const { stateless, watch, onChange, options: usecaseOptions, ...restUseCaseOptions } = options;
+    const optionsGetterListRef = useRef([]);
+    const deps = (hasDefaultEntity ? arg4 : arg3) || [];
+    const [usecase] = useState(() => {
+        return hasDefaultEntity
+            ? arg2
+            : arg1;
+    });
+    const [context] = useState(() => {
+        const map = usecaseContextMap;
+        const entityUseCase = usecase;
+        if (map.has(entityUseCase)) {
+            return map.get(entityUseCase);
+        }
+        if (!hasDefaultEntity) {
+            return defaultUseCaseContext;
+        }
+        const ctx = createContext(null);
+        map.set(entityUseCase, ctx);
+        return ctx;
+    });
+    const [contextEntity, contextEntityReducers, contextCollectionReducers] = useContext(context) || [];
+    const entity = useMemo(() => {
+        if (!hasDefaultEntity) {
+            return contextEntity;
+        }
+        if (!stateless) {
+            return entityState;
+        }
+        if (typeof arg1 !== 'function') {
+            return arg1;
+        }
+        return arg1();
+    }, [hasDefaultEntity, contextEntity, stateless, entityState, arg1]);
+    const initReducers = useMemoizedFn(() => {
+        const mergedOptions = { ...restUseCaseOptions, ...usecaseOptions };
+        if (!hasDefaultEntity) {
+            return contextEntityReducers || usecase(mergedOptions);
+        }
+        const { createEntityReducers } = entityReducerUseCase();
+        return createEntityReducers(entity, usecase, {
+            ...mergedOptions,
+            onChange(newEntity, prevEntity) {
+                if (hasDefaultEntity && !stateless) {
+                    setEntityState(newEntity);
+                }
+                triggerCallbacks(optionsGetterListRef.current, newEntity, prevEntity);
+            },
+            onGenerate(newEntity, result) {
+                return result;
+            },
+        });
+    });
+    const reducers = useMemo.call(null, initReducers, [entity, initReducers, ...deps]);
+    const collectionReducers = useMemo(() => {
+        if (!hasDefaultEntity && contextCollectionReducers) {
+            return contextCollectionReducers;
+        }
+        return optionsGetterCollectionUseCase(optionsGetterListRef.current);
+    }, [hasDefaultEntity, contextCollectionReducers]);
+    const contextValueWithCollectionReducers = useMemo(() => {
+        return [entity, reducers, collectionReducers];
+    }, [entity, reducers, collectionReducers]);
+    const contextValueWithCollectionReducersRef = useLatest(contextValueWithCollectionReducers);
+    const [Provider] = useState(() => {
+        return ({ children }) => {
+            const { Provider: ContextProvider } = context;
+            return React.createElement(ContextProvider, {
+                value: contextValueWithCollectionReducersRef.current,
+            }, children);
+        };
+    });
+    const contextValue = useMemo(() => {
+        if (hasDefaultEntity) {
+            return [entity, reducers, Provider];
+        }
+        return [entity, reducers];
+    }, [entity, reducers, hasDefaultEntity, Provider]);
+    const result = useMemo(() => {
+        if (context === defaultUseCaseContext) {
+            return reducers;
+        }
+        return contextValue;
+    }, [context, reducers, contextValue]);
+    void useOptionsTransfer(options, collectionReducers);
+    return result;
+});

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

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