@mic-rexjs/usecases-react 3.7.0 → 4.0.0-beta.3

package/es/hooks/useEntity/index.js

@@ -1,31 +1,27 @@
 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 { useEffect, useRef } from 'react';
+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, options) => {
+export const useEntity = (store,
+// 强制传入 `reducers` 参数，目的是让该 `hook` 一定在 `useReducers` 之后执行
+reducers, statuses, options) => {
   const entity = store.value;
-  const update = useUpdate();
-  const isInitializing = useEntityInitializing(statuses);
+  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 = optionsRef.current.watch;
@@ -37,10 +33,10 @@ export const useEntity = (store, statuses, options) => {
   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 prevEntity = prevEntityRef.current;
+    if (!hasEntity) {
       return;
     }
-    const prevEntity = prevEntityRef.current;
     if (prevEntity === newEntity) {
       return;
     }
@@ -54,41 +50,45 @@ export const useEntity = (store, statuses, options) => {
     onAdopt === null || onAdopt === void 0 || onAdopt(newEntity, oldEntity);
     onUpdate === null || onUpdate === void 0 || onUpdate(newEntity, oldEntity);
   });
-  const onEntityChange = useMemoizedFn((newEntity, oldEntity) => {
-    const currentOptions = optionsRef.current;
-    const onChange1 = currentOptions.onChange;
+  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);
-  });
-  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,22 +97,21 @@ export const useEntity = (store, statuses, options) => {
    * 需要马上 `watch`，因为 `useEffect` 在子组件内优先执行，
    * 如果使用了 `setEntity` 则无法监控到变化
    */
-  useExec(() => {
-    if (!entityEnabled) {
-      return;
-    }
-    store.watch(onEntityChange);
-  }, [store, entityEnabled, onEntityChange]);
+  useEntityReturn(statuses, () => {
+    store.watch(onEntityOptionsChange);
+    store.watch(onEntityUpdate);
+  },
   /**
    * 在变化时候，组件更新前，使用 `unwatch`
    */
-  useEffect(() => {
-    return () => {
-      store.unwatch(onEntityChange);
-    };
-  }, [store, entityEnabled, onEntityChange]);
+  () => {
+    store.unwatch(onEntityOptionsChange);
+    store.unwatch(onEntityUpdate);
+  }, [store]);
   useUpdateEffect(() => {
     onEntityUpdate();
   }, [entity, onEntityUpdate]);
+  // 强制传入 `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/useEntityRootExec/types.js

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

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 } from './types';
-import { RestArguments } from '@mic-rexjs/usecases/es/types';
-export declare const useExec: <T>(callback: ExecCallback<T>, deps?: RestArguments) => T;
+import { ExecHook } from './types';
+export declare const useExec: ExecHook;

package/es/hooks/useExec/index.js

@@ -1,13 +1,4 @@
-import { useDepsKey } from '../useDepsKey';
-import { useCreation, useMemoizedFn } from 'ahooks';
-export const useExec = function (callback) {
-  let deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [callback];
-  const depsKey = useDepsKey(deps);
-  const execCallback = useMemoizedFn(() => {
-    return callback();
-  });
-  return useCreation(() => {
-    void depsKey;
-    return execCallback();
-  }, [depsKey, execCallback]);
+import { useReturn } from '../useReturn';
+export const useExec = function () {
+  void useReturn(...arguments);
 };

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

@@ -1,3 +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/useFullArguments/types.d.ts

@@ -1,10 +1,10 @@
 import { EntityReducers, EntityUseCase, UseCase } from '@mic-rexjs/usecases';
 import { ReducerMap } from '@mic-rexjs/usecases/es/types';
-import { UseCaseHookContextualOptions, UseCaseHookOptions } from '../../hooks/useUseCase/types';
+import { ContextualUseCaseHookOptions, UseCaseHookOptions } from '../../hooks/useUseCase/types';
 import { Dependencies, EntityInitializer } from '../../types';
 export type FullParameters<T, TReducers extends ReducerMap, TUseCaseOptions extends object> = [
     entity: T | EntityInitializer<T>,
     usecase: UseCase<TReducers, TUseCaseOptions> | EntityUseCase<T, TReducers & EntityReducers<T>, TUseCaseOptions>,
-    options: TUseCaseOptions | UseCaseHookOptions<T, TUseCaseOptions> | UseCaseHookContextualOptions<T>,
+    options: TUseCaseOptions | UseCaseHookOptions<T, TUseCaseOptions> | ContextualUseCaseHookOptions<T>,
     deps: Dependencies
 ];

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,6 +1,4 @@
 import { UseCaseProvider } from './types';
-import { EntityStore } from '@mic-rexjs/usecases';
-import { ReducerMap } from '@mic-rexjs/usecases/es/types';
-import { Statuses } from '../../enums/Statuses';
-import { UseCaseContext, UseCaseContextValue } from '../../usecases/contextUseCase/types';
-export declare const useProvider: <T, TReducers extends ReducerMap>(statuses: Statuses, context: UseCaseContext<UseCaseContextValue<TReducers>>, store: EntityStore<T>, reducers: TReducers) => 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,27 +1,21 @@
-import { useConstantFn } from '../useConstantFn';
-import { useCreation, useLatest } from 'ahooks';
+import { useConstant } from '../useConstant';
+import { useLatest } from 'ahooks';
 import React from 'react';
-import { contextUseCase } from '../../usecases/contextUseCase';
-export const useProvider = (statuses, context, store, reducers) => {
-  const entity = store.value;
-  const contextValue = useCreation(() => {
-    const _contextUseCase = contextUseCase(),
-      createContextValue = _contextUseCase.createContextValue;
-    void entity;
-    return createContextValue(store, reducers, statuses);
-  }, [statuses, entity, store, reducers]);
+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, TUseCaseOptions extends object>(usecase: UseCase<TReducers, TUseCaseOptions> | EntityUseCase<T, TReducers & EntityReducers<T>, TUseCaseOptions>, context: UseCaseContext<UseCaseContextValue<TReducers>>, store: EntityStore<T>, statuses: Statuses, options: TUseCaseOptions, 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,43 +1,61 @@
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-const _excluded = ["watch", "onChange", "options"];
-import { useContextualItem } from '../useContextualItem';
+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';
-import { methodUseCase } from '../../usecases/methodUseCase';
-export const useReducers = function (usecase, context, store, statuses, options) {
-  let deps = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
-  const optionsRef = useLatest(options);
+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 entityRootEnabled = (statuses & Statuses.EntityRootEnabled) === Statuses.EntityRootEnabled;
-  const onCreate = () => {
-    const _methodUseCase = methodUseCase(),
-      captureCalls = _methodUseCase.captureCalls;
-    const opts = captureCalls(options, (key, callArgs) => {
-      var _optionsRef$current$k, _optionsRef$current;
-      return (_optionsRef$current$k = (_optionsRef$current = optionsRef.current)[key]) === null || _optionsRef$current$k === void 0 ? void 0 : _optionsRef$current$k.call(_optionsRef$current, ...callArgs);
-    });
-    if (!entityRootEnabled) {
-      return usecase(opts);
+  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);
     }
-    const hookOptions = opts;
-    const watch = hookOptions.watch,
-      onChange = hookOptions.onChange,
-      usecaseOptions = hookOptions.options,
-      restUseCaseOptions = _objectWithoutProperties(hookOptions, _excluded);
+    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, {
-      ...restUseCaseOptions,
-      ...usecaseOptions,
+      options: newOptions,
       onGenerate(newEntity, result) {
         return result;
       }
     });
-  };
-  return useContextualItem(contextReducers, statuses, () => {
-    return 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]);
+};