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

package/es/hooks/useEntity/index.js

@@ -1,46 +1,40 @@
 import { useConstant } from '../useConstant';
-import { useConstantReducers } from '../useConstantReducers';
-import { useEntityInitializing } from '../useEntityInitializing';
-import { useExec } from '../useExec';
-import { utilsUseCase } from '@mic-rexjs/usecases';
-import { useLatest, useMemoizedFn, useUnmount, useUpdate, useUpdateEffect } from 'ahooks';
+import { useEntityReturn } from '../useEntityReturn';
+import { useEntityRootExec } from '../useEntityRootExec';
+import { useThrottleUpdate } from '../useThrottleUpdate';
+import { useLatest, useMemoizedFn, useUpdateEffect } from 'ahooks';
 import { useRef } from 'react';
 import { Statuses } from '../../enums/Statuses';
 import { triggerWatchers } from '../../methods/triggerWatchers';
 import { lifecycleEventUseCase } from '../../usecases/lifecycleEventUseCase';
-export const useEntity = (store, statuses, hookOptions) => {
+export const useEntity = (store,
+// 强制传入 `reducers` 参数，目的是让该 `hook` 一定在 `useReducers` 之后执行
+reducers, statuses, options) => {
   const entity = store.value;
-  const update = useUpdate();
-  const isInitializing = useEntityInitializing(statuses);
-  const hookOptionsRef = useLatest(hookOptions);
+  const update = useThrottleUpdate();
+  const optionsRef = useLatest(options);
   const prevEntityRef = useRef(entity);
-  const entityEnabled = (statuses & Statuses.EntityEnabled) === Statuses.EntityEnabled;
-  const entityRootEnabled = (statuses & Statuses.EntityRootEnabled) === Statuses.EntityRootEnabled;
-  const _useConstantReducers = useConstantReducers(() => {
-      return lifecycleEventUseCase();
-    }),
-    bindLifecycleEventsKey = _useConstantReducers.bindLifecycleEventsKey,
-    getLifecycleEvents = _useConstantReducers.getLifecycleEvents,
-    deleteLifecycleEvents = _useConstantReducers.deleteLifecycleEvents;
+  const hasEntity = (statuses & Statuses.Entity) === Statuses.Entity;
+  const lifecycleReducers = useConstant(lifecycleEventUseCase);
+  const createLifecycleKey = lifecycleReducers.createLifecycleKey,
+    bindLifecycleEventsKey = lifecycleReducers.bindLifecycleEventsKey,
+    getLifecycleEvents = lifecycleReducers.getLifecycleEvents,
+    deleteLifecycleEvents = lifecycleReducers.deleteLifecycleEvents;
   const lifecycleKey = useConstant(() => {
-    const _utilsUseCase = utilsUseCase(),
-      createKey = _utilsUseCase.createKey;
-    return createKey();
+    return createLifecycleKey();
   });
   const onTriggerWatchers = useMemoizedFn((newEntity, oldEntity) => {
-    const watch = hookOptionsRef.current.watch;
+    const watch = optionsRef.current.watch;
     if (!watch) {
       return;
     }
     triggerWatchers(watch, newEntity, oldEntity);
   });
-  const onEntityUpdate = useMemoizedFn(function () {
-    let newEntity = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : entity;
-    let oldEntity = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : prevEntityRef.current;
-    if (!entityEnabled) {
+  const onEntityUpdate = useMemoizedFn(newEntity => {
+    const prevEntity = prevEntityRef.current;
+    if (!hasEntity) {
       return;
     }
-    const prevEntity = prevEntityRef.current;
     if (prevEntity === newEntity) {
       return;
     }
@@ -49,46 +43,54 @@ export const useEntity = (store, statuses, hookOptions) => {
       onAdopt = _getLifecycleEvents.onAdopt,
       onDiscard = _getLifecycleEvents.onDiscard;
     prevEntityRef.current = newEntity;
-    onTriggerWatchers(newEntity, oldEntity);
-    onDiscard === null || onDiscard === void 0 || onDiscard(oldEntity);
-    onAdopt === null || onAdopt === void 0 || onAdopt(newEntity, oldEntity);
-    onUpdate === null || onUpdate === void 0 || onUpdate(newEntity, oldEntity);
+    onTriggerWatchers(newEntity, prevEntity);
+    onDiscard === null || onDiscard === void 0 || onDiscard(prevEntity);
+    onAdopt === null || onAdopt === void 0 || onAdopt(newEntity, prevEntity);
+    onUpdate === null || onUpdate === void 0 || onUpdate(newEntity, prevEntity);
   });
-  const onEntityChange = useMemoizedFn((newEntity, oldEntity) => {
-    const currentHookOptions = hookOptionsRef.current;
-    const onChange1 = currentHookOptions.onChange;
+  const onEntityUpdateEffect = useMemoizedFn(() => {
+    // 不能使用 `entity` 变量，因为 `effect` 执行的有延迟，`entity` 可能已经被更新了
+    onEntityUpdate(store.value);
+  });
+  const onEntityLifecycleChange = useMemoizedFn(async (newEntity, oldEntity) => {
     const _getLifecycleEvents2 = getLifecycleEvents(lifecycleKey),
-      onChange2 = _getLifecycleEvents2.onChange;
-    onEntityUpdate(newEntity, oldEntity);
-    onChange1 === null || onChange1 === void 0 || onChange1(newEntity, oldEntity);
-    onChange2 === null || onChange2 === void 0 || onChange2(newEntity, oldEntity);
-    if (!entityRootEnabled) {
+      onChange = _getLifecycleEvents2.onChange;
+    let result = onChange === null || onChange === void 0 ? void 0 : onChange(newEntity, oldEntity);
+    if (result instanceof Promise) {
+      result = await result;
+    }
+    switch (typeof result) {
+      case 'number':
+        update(result);
+        return;
+      case 'undefined':
+        update();
+        return;
+    }
+    if (result) {
       return;
     }
     update();
   });
-  useExec(() => {
-    if (!entityRootEnabled) {
-      return;
-    }
+  const onEntityOptionsChange = useMemoizedFn((newEntity, oldEntity) => {
+    const currentOptions = optionsRef.current;
+    const onChange = currentOptions.onChange;
+    onChange === null || onChange === void 0 || onChange(newEntity, oldEntity);
+  });
+  useEntityRootExec(statuses, () => {
     const _bindLifecycleEventsK = bindLifecycleEventsKey(lifecycleKey),
       onBind = _bindLifecycleEventsK.onBind,
       onAdopt = _bindLifecycleEventsK.onAdopt;
-    if (!isInitializing) {
-      return;
-    }
+    store.watch(onEntityLifecycleChange);
     onBind === null || onBind === void 0 || onBind(entity);
     onAdopt === null || onAdopt === void 0 || onAdopt(entity);
-  }, null, []);
-  useUnmount(() => {
-    if (!entityRootEnabled) {
-      return;
-    }
+  }, () => {
     // 要使用最新的 `entity`
     const currentEntity = store.value;
     const _getLifecycleEvents3 = getLifecycleEvents(lifecycleKey),
       onUnbind = _getLifecycleEvents3.onUnbind,
       onDiscard = _getLifecycleEvents3.onDiscard;
+    store.unwatch(onEntityLifecycleChange);
     deleteLifecycleEvents(lifecycleKey);
     onUnbind === null || onUnbind === void 0 || onUnbind(currentEntity);
     onDiscard === null || onDiscard === void 0 || onDiscard(currentEntity);
@@ -97,20 +99,21 @@ export const useEntity = (store, statuses, hookOptions) => {
    * 需要马上 `watch`，因为 `useEffect` 在子组件内优先执行，
    * 如果使用了 `setEntity` 则无法监控到变化
    */
-  useExec(() => {
-    if (!entityEnabled) {
-      return;
-    }
-    store.watch(onEntityChange);
+  useEntityReturn(statuses, () => {
+    store.watch(onEntityOptionsChange);
+    store.watch(onEntityUpdate);
   },
   /**
    * 在变化时候，组件更新前，使用 `unwatch`
    */
   () => {
-    store.unwatch(onEntityChange);
-  }, [store, entityEnabled, onEntityChange]);
+    store.unwatch(onEntityOptionsChange);
+    store.unwatch(onEntityUpdate);
+  }, [store]);
   useUpdateEffect(() => {
-    onEntityUpdate();
-  }, [entity, onEntityUpdate]);
+    onEntityUpdateEffect();
+  }, [entity, onEntityUpdateEffect]);
+  // 强制传入 `reducers` 参数，目的是让该 `hook` 一定在 `useReducers` 之后执行
+  void reducers;
   return entity;
 };

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

@@ -0,0 +1,5 @@
+import { EntityReturnHook } from './types';
+/**
+ * 只在 `RootCoreCollectionHook` 或 `ContextualCoreCollectionHook` 模式下才会执行相关回调
+ */
+export declare const useEntityReturn: EntityReturnHook;

package/es/hooks/useEntityReturn/index.js

@@ -0,0 +1,15 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useIfReturn } from '../useIfReturn';
+import { Statuses } from '../../enums/Statuses';
+/**
+ * 只在 `RootCoreCollectionHook` 或 `ContextualCoreCollectionHook` 模式下才会执行相关回调
+ */
+export const useEntityReturn = (statuses, callback, arg3, arg4) => {
+  const isDepsArgs = Array.isArray(arg3);
+  const _ref = isDepsArgs ? [null, arg3] : [arg3, arg4],
+    _ref2 = _slicedToArray(_ref, 2),
+    destructor = _ref2[0],
+    deps = _ref2[1];
+  const hasEntity = (statuses & Statuses.Entity) === Statuses.Entity;
+  return useIfReturn(hasEntity, callback, destructor || null, deps);
+};

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

@@ -0,0 +1,7 @@
+import { ReturnCallback, ReturnDestructor } from '../useReturn/types';
+import { Statuses } from '../../enums/Statuses';
+import { Dependencies } from '../../types';
+export interface EntityReturnHook {
+    <T>(statuses: Statuses, callback: ReturnCallback<T>, deps?: Dependencies): T | null;
+    <T>(statuses: Statuses, callback: ReturnCallback<T>, destructor: ReturnDestructor | null, deps?: Dependencies): T | null;
+}

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

@@ -0,0 +1,5 @@
+import { EntityRootExecHook } from './types';
+/**
+ * 只在 `RootCoreCollectionHook` 模式下才会执行相关回调
+ */
+export declare const useEntityRootExec: EntityRootExecHook;

package/es/hooks/useEntityRootExec/index.js

@@ -0,0 +1,7 @@
+import { useEntityRootReturn } from '../useEntityRootReturn';
+/**
+ * 只在 `RootCoreCollectionHook` 模式下才会执行相关回调
+ */
+export const useEntityRootExec = function () {
+  void useEntityRootReturn(...arguments);
+};

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

@@ -0,0 +1,7 @@
+import { ExecCallback, ExecDestructor } from '../useExec/types';
+import { Statuses } from '../../enums/Statuses';
+import { Dependencies } from '../../types';
+export interface EntityRootExecHook {
+    (statuses: Statuses, callback: ExecCallback, deps?: Dependencies): void;
+    (statuses: Statuses, callback: ExecCallback, destructor: ExecDestructor | null, deps?: Dependencies): void;
+}

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

@@ -0,0 +1,5 @@
+import { EntityRootReturnHook } from './types';
+/**
+ * 只在 `RootCoreCollectionHook` 模式下才会执行相关回调
+ */
+export declare const useEntityRootReturn: EntityRootReturnHook;

package/es/hooks/useEntityRootReturn/index.js

@@ -0,0 +1,14 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useRootReturn } from '../useRootReturn';
+import { Statuses } from '../../enums/Statuses';
+/**
+ * 只在 `RootCoreCollectionHook` 模式下才会执行相关回调
+ */
+export const useEntityRootReturn = (statuses, callback, arg3, arg4) => {
+  const isDepsArgs = Array.isArray(arg3);
+  const _ref = isDepsArgs ? [null, arg3] : [arg3, arg4],
+    _ref2 = _slicedToArray(_ref, 2),
+    destructor = _ref2[0],
+    deps = _ref2[1];
+  return useRootReturn(statuses, callback, destructor || null, Statuses.EntityRootRuntime, deps);
+};

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

@@ -0,0 +1,7 @@
+import { RootReturnCallback, RootReturnDestructor } from '../useRootReturn/types';
+import { Statuses } from '../../enums/Statuses';
+import { Dependencies } from '../../types';
+export interface EntityRootReturnHook {
+    <T>(statuses: Statuses, callback: RootReturnCallback<T>, deps?: Dependencies): T | null;
+    <T>(statuses: Statuses, callback: RootReturnCallback<T>, destructor: RootReturnDestructor | null, deps?: Dependencies): T | null;
+}

package/es/hooks/useEntityRootReturn/types.js

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

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

@@ -1,3 +1,2 @@
-import { ExecCallback, ExecDestructor } from './types';
-import { RestArguments } from '@mic-rexjs/usecases/es/types';
-export declare const useExec: <T>(callback: ExecCallback<T>, destructor?: ExecDestructor | null, deps?: RestArguments) => T;
+import { ExecHook } from './types';
+export declare const useExec: ExecHook;

package/es/hooks/useExec/index.js

@@ -1,26 +1,4 @@
-import { useDepsKey } from '../useDepsKey';
-import { useCreation, useMemoizedFn, useUnmount } from 'ahooks';
-import { useRef } from 'react';
-export const useExec = function (callback, destructor) {
-  let deps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [callback];
-  const depsKey = useDepsKey(deps);
-  const destructorRef = useRef(null);
-  const onDestruct = function () {
-    var _destructorRef$curren;
-    let isUnmount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    (_destructorRef$curren = destructorRef.current) === null || _destructorRef$curren === void 0 || _destructorRef$curren.call(destructorRef, isUnmount);
-  };
-  const onExec = useMemoizedFn(() => {
-    onDestruct();
-    // `destructor` 一定是在执行回调的时候，同步绑定的，保持两个回调内的闭包变量一致
-    destructorRef.current = destructor || null;
-    return callback();
-  });
-  useUnmount(() => {
-    onDestruct(true);
-  });
-  return useCreation(() => {
-    void depsKey;
-    return onExec();
-  }, [depsKey, onExec]);
+import { useReturn } from '../useReturn';
+export const useExec = function () {
+  void useReturn(...arguments);
 };

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

@@ -1,6 +1,11 @@
-export interface ExecCallback<T> {
-    (): T;
+import { Dependencies } from '../../types';
+export interface ExecCallback {
+    (): void;
 }
 export interface ExecDestructor {
     (isUnmount: boolean): void;
 }
+export interface ExecHook {
+    (callback: ExecCallback, deps?: Dependencies): void;
+    (callback: ExecCallback, destructor: ExecDestructor | null, deps?: Dependencies): void;
+}

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

@@ -1,5 +1,4 @@
 import { FullParameters } from './types';
-import { ReducerMap } from '@mic-rexjs/usecases/es/types';
-import { ArgumentTypes } from '../../enums/ArgumentTypes';
 import { UseCaseHookParameters } from '../../hooks/useUseCase/types';
-export declare const useFullArguments: <T, TReducers extends ReducerMap, TUseCaseOptions extends object>(args: UseCaseHookParameters, argumentTypes: ArgumentTypes) => FullParameters<T, TReducers, TUseCaseOptions>;
+import { UnknownReducerMap } from '../../types';
+export declare const useFullArguments: <T, TReducers extends UnknownReducerMap<T>, TUseCaseOptions extends object>(args: UseCaseHookParameters, isEntityRoot: boolean) => FullParameters<T, TReducers, TUseCaseOptions>;

package/es/hooks/useFullArguments/index.js

@@ -1,14 +1,12 @@
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import { ArgumentTypes } from '../../enums/ArgumentTypes';
-export const useFullArguments = (args, argumentTypes) => {
+export const useFullArguments = (args, isEntityRoot) => {
   const _args = _slicedToArray(args, 4),
     arg1 = _args[0],
     arg2 = _args[1],
     arg3 = _args[2],
     arg4 = _args[3];
-  const withoutEntity = (argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity;
-  if (withoutEntity) {
-    return [null, arg1, arg2 || {}, arg3 || []];
+  if (isEntityRoot) {
+    return [arg1, arg2, arg3 || {}, arg4 || []];
   }
-  return [arg1, arg2, arg3 || {}, arg4 || []];
+  return [null, arg1, arg2 || {}, arg3 || []];
 };

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

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

package/es/hooks/useIfExec/index.js

@@ -0,0 +1,20 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useExec } from '../useExec';
+export const useIfExec = (value, callback, arg3, arg4) => {
+  const hasDestructor = typeof arg3 === 'function' || arg3 === null;
+  const _ref = hasDestructor ? [arg3, arg4] : [null, arg3],
+    _ref2 = _slicedToArray(_ref, 2),
+    destructor = _ref2[0],
+    deps = _ref2[1];
+  return useExec(() => {
+    if (!value) {
+      return;
+    }
+    callback();
+  }, isUnmount => {
+    if (!value) {
+      return;
+    }
+    destructor === null || destructor === void 0 || destructor(isUnmount);
+  }, deps);
+};

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

@@ -0,0 +1,6 @@
+import { ExecCallback, ExecDestructor } from '../useExec/types';
+import { Dependencies } from '../../types';
+export interface TrueExecHook {
+    <T>(value: boolean, callback: ExecCallback, deps?: Dependencies): T;
+    <T>(value: boolean, callback: ExecCallback, destructor: ExecDestructor | null, deps?: Dependencies): T;
+}

package/es/hooks/useIfExec/types.js

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

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

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

package/es/hooks/useIfReturn/index.js

@@ -0,0 +1,22 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useReturn } from '../useReturn';
+export const useIfReturn = (value, callback, arg3,
+// 默认：如果 `callback` 没有用 `useMemorizedFn`，就会每次都执行，否则只执行一次
+arg4) => {
+  const isDepsArg3 = Array.isArray(arg3);
+  const _ref = isDepsArg3 ? [null, arg3] : [arg3, arg4],
+    _ref2 = _slicedToArray(_ref, 2),
+    destructor = _ref2[0],
+    deps = _ref2[1];
+  return useReturn(() => {
+    if (!value) {
+      return null;
+    }
+    return callback();
+  }, isUnmount => {
+    if (!value) {
+      return;
+    }
+    destructor === null || destructor === void 0 || destructor(isUnmount);
+  }, deps);
+};

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

@@ -0,0 +1,6 @@
+import { ReturnCallback, ReturnDestructor } from '../useReturn/types';
+import { Dependencies } from '../../types';
+export interface IfReturnHook {
+    <T>(value: boolean, callback: ReturnCallback<T>, deps?: Dependencies): T | null;
+    <T>(value: boolean, callback: ReturnCallback<T>, destructor: ReturnDestructor | null, deps?: Dependencies): T | null;
+}

package/es/hooks/useIfReturn/types.js

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

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

@@ -1,4 +1,4 @@
 import { UseCaseProvider } from './types';
-import { ReducerMap } from '@mic-rexjs/usecases/es/types';
-import { UseCaseContext, UseCaseContextValue } from '../../usecases/contextUseCase/types';
-export declare const useProvider: <T extends ReducerMap, TContextValue extends UseCaseContextValue<T>>(context: UseCaseContext<TContextValue>, contextValue: TContextValue) => UseCaseProvider;
+import { UnknownReducerMap } from '../../types';
+import { EntityUseCaseContextValue, UseCaseContext } from '../../usecases/contextUseCase/types';
+export declare const useProvider: <T, TReducers extends UnknownReducerMap<T>, TContextValue extends EntityUseCaseContextValue<T, TReducers>>(context: UseCaseContext<TContextValue>, contextValue: TContextValue) => UseCaseProvider;

package/es/hooks/useProvider/index.js

@@ -1,19 +1,21 @@
-import { useConstantFn } from '../useConstantFn';
+import { useConstant } from '../useConstant';
 import { useLatest } from 'ahooks';
 import React from 'react';
 export const useProvider = (context, contextValue) => {
   const contextValueRef = useLatest(contextValue);
-  return useConstantFn(_ref => {
-    let children = _ref.children,
-      _ref$with = _ref.with,
-      withProviders = _ref$with === void 0 ? [] : _ref$with;
-    const ContextProvider = context.Provider;
-    const value = contextValueRef.current;
-    const providers = Array.isArray(withProviders) ? withProviders : [withProviders];
-    return React.createElement(ContextProvider, {
-      value
-    }, providers.reduceRight((currentChildren, withProvider) => {
-      return React.createElement(withProvider, {}, currentChildren);
-    }, children));
+  return useConstant(() => {
+    return _ref => {
+      let children = _ref.children,
+        _ref$with = _ref.with,
+        withProviders = _ref$with === void 0 ? [] : _ref$with;
+      const ContextProvider = context.Provider;
+      const value = contextValueRef.current;
+      const providers = Array.isArray(withProviders) ? withProviders : [withProviders];
+      return React.createElement(ContextProvider, {
+        value
+      }, providers.reduceRight((currentChildren, withProvider) => {
+        return React.createElement(withProvider, {}, currentChildren);
+      }, children));
+    };
   });
 };

package/es/hooks/useProviders/index.js

@@ -1,13 +1,13 @@
 import { useDepsKey } from '../useDepsKey';
-import { useCreation, useLatest } from 'ahooks';
+import { useReturn } from '../useReturn';
+import { useLatest } from 'ahooks';
 export const useProviders = function () {
   for (var _len = arguments.length, providers = new Array(_len), _key = 0; _key < _len; _key++) {
     providers[_key] = arguments[_key];
   }
   const depsKey = useDepsKey(providers);
   const providersRef = useLatest(providers);
-  return useCreation(() => {
-    void depsKey;
+  return useReturn(() => {
     return providersRef.current;
-  }, [depsKey, providersRef]);
+  }, [depsKey]);
 };

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

@@ -1,6 +1,7 @@
+import { ContextualUseCaseHookOptions, UseCaseHookOptions } from '../useUseCase/types';
 import { EntityStore } from '@mic-rexjs/usecases';
-import { EntityReducers, EntityUseCase, ReducerMap, UseCase } from '@mic-rexjs/usecases/es/types';
+import { EntityUseCase, UseCase } from '@mic-rexjs/usecases/es/types';
 import { Statuses } from '../../enums/Statuses';
-import { Dependencies } from '../../types';
-import { UseCaseContext, UseCaseContextValue } from '../../usecases/contextUseCase/types';
-export declare const useReducers: <T, TReducers extends ReducerMap, TOptions extends object>(usecase: UseCase<TReducers, TOptions> | EntityUseCase<T, TReducers & EntityReducers<T>, TOptions>, store: EntityStore<T>, context: UseCaseContext<UseCaseContextValue<TReducers>>, statuses: Statuses, usecaseOptions: TOptions, deps?: Dependencies) => TReducers;
+import { UnknownReducerMap } from '../../types';
+import { ContextualEntityReducers, EntityUseCaseContextValue, UseCaseContext } from '../../usecases/contextUseCase/types';
+export declare const useReducers: <T, TReducers extends UnknownReducerMap<T>, TOptions extends object>(usecase: UseCase<TReducers, TOptions> | EntityUseCase<T, TReducers, TOptions>, store: EntityStore<T>, context: UseCaseContext<EntityUseCaseContextValue<T, TReducers>>, statuses: Statuses, options: TOptions | UseCaseHookOptions<T, TOptions> | ContextualUseCaseHookOptions<T>) => TReducers | ContextualEntityReducers<T, TReducers>;

package/es/hooks/useReducers/index.js

@@ -1,24 +1,61 @@
-import { useContextualItem } from '../useContextualItem';
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+const _excluded = ["watch", "onChange"];
+import { useReturn } from '../useReturn';
 import { createEntityReducers } from '@mic-rexjs/usecases';
+import { useLatest } from 'ahooks';
 import { useContext } from 'react';
 import { Statuses } from '../../enums/Statuses';
-export const useReducers = function (usecase, store, context, statuses, usecaseOptions) {
-  let deps = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+export const useReducers = (usecase, store, context, statuses, options) => {
   const contextValue = useContext(context);
   const _ref = contextValue || {},
     _ref$reducers = _ref.reducers,
     contextReducers = _ref$reducers === void 0 ? null : _ref$reducers;
-  const entityEnabled = (statuses & Statuses.EntityEnabled) === Statuses.EntityEnabled;
-  const onCreate = () => {
-    if (!entityEnabled) {
-      return usecase(usecaseOptions);
+  const watch = options.watch,
+    onChange = options.onChange,
+    restOptions = _objectWithoutProperties(options, _excluded);
+  const _options$options = options.options,
+    initailOptions = _options$options === void 0 ? restOptions : _options$options;
+  const initailOptionsRef = useLatest(initailOptions);
+  const reducersKey = statuses & Statuses.ReducersKey;
+  const onOption = key => {
+    return function () {
+      const currentInitailOptions = initailOptionsRef.current;
+      const currentValue = currentInitailOptions[key];
+      if (typeof currentValue !== 'function') {
+        return;
+      }
+      return currentValue(...arguments);
+    };
+  };
+  const onOptions = () => {
+    const newOptions = {
+      ...initailOptions
+    };
+    for (const key of Object.keys(newOptions)) {
+      const optionKey = key;
+      const value = newOptions[optionKey];
+      if (typeof value !== 'function') {
+        continue;
+      }
+      newOptions[optionKey] = onOption(optionKey);
     }
+    return newOptions;
+  };
+  return useReturn(() => {
+    const hasEntity = (statuses & Statuses.Entity) === Statuses.Entity;
+    const isEntityRootRuntime = (statuses & Statuses.EntityRootRuntime) === Statuses.EntityRootRuntime;
+    if (!hasEntity) {
+      return usecase(options);
+    }
+    if (!isEntityRootRuntime) {
+      return contextReducers;
+    }
+    const newOptions = onOptions();
     return createEntityReducers(store, usecase, {
-      options: usecaseOptions,
+      options: newOptions,
       onGenerate(newEntity, result) {
         return result;
       }
     });
-  };
-  return useContextualItem(contextReducers, statuses, onCreate, deps);
+  }, [reducersKey]);
 };

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

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

package/es/hooks/useReturn/index.js

@@ -0,0 +1,33 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useDepsKey } from '../useDepsKey';
+import { useCreation as useAhooksCreation, useMemoizedFn, useUnmount } from 'ahooks';
+import { useRef } from 'react';
+export const useReturn = function (callback) {
+  let arg2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [callback];
+  let arg3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [callback];
+  const hasDestructor = !Array.isArray(arg2);
+  const _ref = hasDestructor ? [arg2, arg3] : [null, arg2],
+    _ref2 = _slicedToArray(_ref, 2),
+    destructor = _ref2[0],
+    deps = _ref2[1];
+  const depsKey = useDepsKey(deps);
+  const destructorRef = useRef(null);
+  const onDestruct = function () {
+    var _destructorRef$curren;
+    let isUnmount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    (_destructorRef$curren = destructorRef.current) === null || _destructorRef$curren === void 0 || _destructorRef$curren.call(destructorRef, isUnmount);
+  };
+  const onCreate = useMemoizedFn(() => {
+    onDestruct();
+    // `destructor` 一定是在执行回调的时候，同步绑定的，保持两个回调内的闭包变量一致
+    destructorRef.current = destructor;
+    return callback();
+  });
+  useUnmount(() => {
+    onDestruct(true);
+  });
+  return useAhooksCreation(() => {
+    void depsKey;
+    return onCreate();
+  }, [depsKey, onCreate]);
+};

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

@@ -0,0 +1,11 @@
+import { Dependencies } from '../../types';
+export interface ReturnCallback<T> {
+    (): T;
+}
+export interface ReturnDestructor {
+    (isUnmount: boolean): void;
+}
+export interface ReturnHook {
+    <T>(callback: ReturnCallback<T>, deps?: Dependencies): T;
+    <T>(callback: ReturnCallback<T>, destructor: ReturnDestructor | null, deps?: Dependencies): T;
+}

package/es/hooks/useReturn/types.js

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

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

@@ -0,0 +1,2 @@
+import { Statuses } from '../../enums/Statuses';
+export declare const useRootInitializing: (statuses: Statuses) => boolean;