@mic-rexjs/usecases-react 3.6.3 → 4.0.0-beta.0

package/es/hooks/useStore/index.js

@@ -34,17 +34,6 @@ export const useStore = function (entityArg, context, statuses) {
     const createEntityList = createEntityListRef.current;
     createEntityListRef.current = runEntityInitializer(store, entityArg, createEntityList, isInitializing);
   };
-  const onSetEntity = () => {
-    if (isInitializing) {
-      store.initValue(entityArg);
-      return;
-    }
-    if (entityArg === prevEntityArg) {
-      return;
-    }
-    // 执行同步操作
-    store.setValue(entityArg);
-  };
   /**
    * 这里仅仅是将非函数的 `entity` 同步；
    *
@@ -56,8 +45,14 @@ export const useStore = function (entityArg, context, statuses) {
       case !entityRootEnabled:
       case isFunction:
         return;
+      case isInitializing:
+        store.initValue(entityArg);
+        return;
+      case entityArg === prevEntityArg:
+        return;
     }
-    onSetEntity();
+    // 执行同步操作
+    store.setValue(entityArg);
   });
   return useContextualItem(contextStore, statuses, () => {
     if (entityRootEnabled && isFunction) {

package/es/hooks/useUseCase/index.js

@@ -2,16 +2,19 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { useArgumentTypes } from '../useArgumentTypes';
 import { useConstantFn } from '../useConstantFn';
 import { useContext } from '../useContext';
+import { useContextValue } from '../useContextValue';
 import { useEntity } from '../useEntity';
 import { useFullArguments } from '../useFullArguments';
 import { useIsRenderingRef } from '../useIsRenderingRef';
+import { useOptions } from '../useOptions';
+import { useOptionsSet } from '../useOptionsSet';
 import { useProvider } from '../useProvider';
 import { useReducers } from '../useReducers';
 import { useStatuses } from '../useStatuses';
 import { useStore } from '../useStore';
 import { useCreation } from 'ahooks';
 import { Statuses } from '../../enums/Statuses';
-import { methodUseCase } from '../../usecases/methodUseCase';
+import { cacheCalls } from '../../methods/cacheCalls';
 export const useUseCase = function () {
   const isRenderingRef = useIsRenderingRef();
   for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -29,15 +32,18 @@ export const useUseCase = function () {
   const entityContext = context;
   const statuses = useStatuses(context, argumentTypes);
   const store = useStore(unsafeEntity, entityContext, statuses, deps);
-  const reducers = useReducers(usecase, context, store, statuses, options, deps);
-  const entity = useEntity(store, statuses, options);
-  const Provider = useProvider(statuses, context, store, reducers);
+  const optionsSet = useOptionsSet(entityContext, statuses);
+  const _useOptions = useOptions(options, optionsSet, statuses, deps),
+    hookOptions = _useOptions.hookOptions,
+    usecaseOptions = _useOptions.usecaseOptions;
+  const reducers = useReducers(usecase, store, context, statuses, usecaseOptions, deps);
+  const entity = useEntity(store, statuses, hookOptions);
+  const contextValue = useContextValue(store, reducers, optionsSet, statuses);
+  const Provider = useProvider(context, contextValue);
   return useCreation(() => {
     if ((statuses & Statuses.EntityEnabled) !== Statuses.EntityEnabled) {
       return reducers;
     }
-    const _methodUseCase = methodUseCase(),
-      cacheCalls = _methodUseCase.cacheCalls;
     const cachedReducers = cacheCalls(reducers, {
       onShouldCache() {
         return isRenderingRef.current;