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

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

@@ -1,6 +1,7 @@
 import { UseCaseProvider } from '../useProvider/types';
 import { UseCase } from '@mic-rexjs/usecases';
 import { EntityReducerMap, EntityReducers, InferableEntityUseCase, ReducerMap, RestArguments, SymbolSet, SymbolSetTarget } from '@mic-rexjs/usecases/es/types';
+import { VoidifyEventOptions } from '../../classes/OptionsSet/types';
 import { MatchPropertyFailedResult } from '../../entities/matchPropertyFailedResult/types';
 import { Dependencies, EntityInitializer } from '../../types';
 import { ContextualEntityReducers } from '../../usecases/contextUseCase/types';
@@ -20,8 +21,6 @@ export type RootCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> =
  * @deprecated 请用 `CoreCollection` 代替
  */
 export type ContextualCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = CoreCollection<T, TEntityReducers>;
-export interface EntityGetter<T> extends EntityInitializer<T> {
-}
 export interface EntityWatchEvent<T, TValue = unknown> extends MatchPropertyFailedResult<T, TValue> {
 }
 export interface EntityWatcher<T, TValue = unknown> {
@@ -37,11 +36,11 @@ export type ExtractFieldType<T, TPath> = TPath extends `${infer TKey}.${infer TS
 export type EntityWatchMap<T> = {
     [K in FieldPath<T>]?: EntityWatcher<T, ExtractFieldType<T, K>>;
 };
-export interface UseCaseHookContextualOptions<T> {
+export interface ContextualUseCaseHookOptions<T> {
     watch?: EntityWatchMap<T>;
     onChange?(newEntity: T, oldEntity: T): void;
 }
-export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extends UseCaseHookContextualOptions<T> {
+export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extends ContextualUseCaseHookOptions<T> {
     options?: TUseCaseOptions;
 }
 export type UnextendFunctionTypes<T> = T extends (...args: infer TArgs) => infer TReturn ? (...args: TArgs) => TReturn : T;
@@ -53,7 +52,7 @@ export interface ReducersHook {
     <T extends ReducerMap, TUseCaseOptions extends object = object>(usecase: UseCase<T & SymbolSetTarget<NonEntitySymbolSet>, TUseCaseOptions>, options?: TUseCaseOptions, deps?: Dependencies): T;
 }
 export interface ContextualCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducerMap<T>>(usecase: InferableEntityUseCase<T, TEntityReducers>, options?: UseCaseHookContextualOptions<T>, deps?: Dependencies): CoreCollection<T, TEntityReducers>;
+    <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object>(usecase: InferableEntityUseCase<T, TEntityReducers, TUseCaseOptions>, options?: UseCaseHookOptions<T, VoidifyEventOptions<TUseCaseOptions>>): CoreCollection<T, TEntityReducers>;
 }
 export interface RootCoreCollectionHook {
     <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object>(entity: T | EntityInitializer<T>, usecase: InferableEntityUseCase<T, TEntityReducers & EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: Dependencies): CoreCollection<T, EntityReducers<T, TEntityReducers>>;

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

@@ -0,0 +1,2 @@
+import { CacheableFactory, CacheCallOptions } from './types';
+export declare const cacheCall: <T extends CacheableFactory>(factory: T, options?: CacheCallOptions) => T;

package/es/methods/cacheCall/index.js

@@ -0,0 +1,38 @@
+import { objectUtilsUseCase } from '../../usecases/objectUtilsUseCase';
+export const cacheCall = (factory, options) => {
+  let cache;
+  const _objectUtilsUseCase = objectUtilsUseCase(),
+    isEqual = _objectUtilsUseCase.isEqual;
+  const _ref = options || {},
+    _ref$onShouldCache = _ref.onShouldCache,
+    onShouldCache = _ref$onShouldCache === void 0 ? () => {
+      return true;
+    } : _ref$onShouldCache,
+    _ref$onCompare = _ref.onCompare,
+    onCompare = _ref$onCompare === void 0 ? (newArgs, oldArgs) => {
+      return isEqual(newArgs, oldArgs);
+    } : _ref$onCompare;
+  return new Proxy(factory, {
+    apply(target, thisArg) {
+      let argList = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      const args = argList;
+      const cacheable = onShouldCache();
+      if (cache && cacheable) {
+        const _cache = cache,
+          parameters = _cache.parameters,
+          returnValue = _cache.returnValue;
+        if (onCompare(parameters, args)) {
+          return returnValue;
+        }
+      }
+      const returnValue = Reflect.apply(target, thisArg, args);
+      if (cacheable) {
+        cache = {
+          parameters: args,
+          returnValue
+        };
+      }
+      return returnValue;
+    }
+  });
+};

package/es/methods/cacheCall/types.d.ts

@@ -0,0 +1,12 @@
+import { RestArguments } from '@mic-rexjs/usecases/es/types';
+export interface CacheableFactory {
+    (...args: RestArguments): unknown;
+}
+export interface CacheCallOptions {
+    onShouldCache?(): boolean;
+    onCompare?(newArgs: RestArguments, oldArgs: RestArguments): boolean;
+}
+export interface CallCache<T extends CacheableFactory> {
+    parameters: Parameters<T>;
+    returnValue: ReturnType<T>;
+}

package/es/methods/cacheCall/types.js

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

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

@@ -0,0 +1,2 @@
+import { CacheableFactory, CacheCallOptions } from '../cacheCall/types';
+export declare const cacheCalls: <T extends Record<string, CacheableFactory>>(sourceFactories: T, options?: CacheCallOptions) => T;

package/es/methods/cacheCalls/index.js

@@ -0,0 +1,12 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { cacheCall } from '../cacheCall';
+export const cacheCalls = (sourceFactories, options) => {
+  const cachedFactories = {};
+  Object.entries(sourceFactories).forEach(_ref => {
+    let _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      factory = _ref2[1];
+    cachedFactories[key] = cacheCall(factory, options);
+  });
+  return cachedFactories;
+};

package/es/usecases/contextUseCase/types.d.ts

@@ -1,13 +1,15 @@
 import { AsyncEntityGenerator, EntityGenerator, EntityReducer, EntityStore, ReducerKeys, Reducers } from '@mic-rexjs/usecases';
 import { EntityReducerMap, InferableUseCase, ReducerMap } from '@mic-rexjs/usecases/es/types';
+import { OptionsSet } from '../../classes/OptionsSet';
 import { ArgumentTypes } from '../../enums/ArgumentTypes';
 import { Statuses } from '../../enums/Statuses';
 export interface UseCaseContextValue<T extends ReducerMap> {
     reducers: T;
     statuses: Statuses;
 }
-export interface EntityUseCaseContextValue<T, TEntityReducers extends EntityReducerMap<T>> extends UseCaseContextValue<ContextualEntityReducers<T, TEntityReducers>> {
+export interface EntityUseCaseContextValue<T, TEntityReducers extends EntityReducerMap<T>, TOptions = object> extends UseCaseContextValue<ContextualEntityReducers<T, TEntityReducers>> {
     store: EntityStore<T>;
+    optionsSet: OptionsSet<TOptions>;
 }
 export interface UseCaseContext<T> extends React.Context<T | null> {
 }

package/es/usecases/lifecycleEventUseCase/types.d.ts

@@ -10,6 +10,13 @@ export interface LifecycleEvents<T = unknown> {
      * `unmount` 的时候触发。
      */
     onUnbind(entity: T): void;
+    /**
+     * 使用新的 `entity` 的时候触发，包括：
+     *
+     * 1. `onBind` 的时候；
+     * 2. `onUpdate` 或 `onChange` 的时候。
+     */
+    onAdopt(newEntity: T, oldEntity?: T): void;
     /**
      * 非渲染阶段触发，随后会触发组件的更新：
      *
@@ -24,6 +31,13 @@ export interface LifecycleEvents<T = unknown> {
      * 2. 由 `useUseCase(entity, usecase)` 中的 `entity` 变化触发 - 渲染阶段。
      */
     onUpdate(newEntity: T, oldEntity: T): void;
+    /**
+     * 当 `entity` 被废弃时候调用，包括以下两种情况：
+     *
+     * 1. `onUpdate` 或 `onChange` 的时候；
+     * 2. `onUnbind` 的时候。
+     */
+    onDiscard(entity: T): void;
 }
 export interface CaptureLifecycleEventsCallback<T> {
     (): T;

package/es/usecases/lifecycleUseCase/index.js

@@ -2,7 +2,9 @@ import { lifecycleEventUseCase } from '../lifecycleEventUseCase';
 import { entityUseCase } from '@mic-rexjs/usecases';
 export const lifecycleUseCase = function () {
   let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  const onBind = options.onBind,
+  const onAdopt = options.onAdopt,
+    onDiscard = options.onDiscard,
+    onBind = options.onBind,
     onUnbind = options.onUnbind,
     onChange = options.onChange,
     onUpdate = options.onUpdate;
@@ -10,6 +12,8 @@ export const lifecycleUseCase = function () {
     setLifecycleEvents = _lifecycleEventUseCas.setLifecycleEvents;
   const entityReducers = entityUseCase();
   setLifecycleEvents({
+    onAdopt,
+    onDiscard,
     onBind,
     onUnbind,
     onChange,

package/lib/classes/OptionsSet/index.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OptionsSet = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } 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 o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = (0, _get2["default"])((0, _getPrototypeOf2["default"])(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+function _classPrivateFieldInitSpec(e, t, a) {
+  _checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+function _checkPrivateRedeclaration(e, t) {
+  if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _classPrivateFieldGet(s, a) {
+  return s.get(_assertClassBrand(s, a));
+}
+function _classPrivateFieldSet(s, a, r) {
+  return s.set(_assertClassBrand(s, a), r), r;
+}
+function _assertClassBrand(e, t, n) {
+  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+  throw new TypeError("Private element is not present on this object");
+}
+var _rootOptions = /*#__PURE__*/new WeakMap();
+var OptionsSet = exports.OptionsSet = /*#__PURE__*/function (_Set) {
+  function OptionsSet() {
+    var _this;
+    (0, _classCallCheck2["default"])(this, OptionsSet);
+    _this = _callSuper(this, OptionsSet, arguments);
+    _classPrivateFieldInitSpec(_this, _rootOptions, null);
+    return _this;
+  }
+  (0, _inherits2["default"])(OptionsSet, _Set);
+  return (0, _createClass2["default"])(OptionsSet, [{
+    key: "add",
+    value: function add(options, root) {
+      if ((0, _typeof2["default"])(options) !== 'object') {
+        return this;
+      }
+      if (root) {
+        _classPrivateFieldSet(_rootOptions, this, options);
+      }
+      _superPropGet(OptionsSet, "add", this, 3)([options]);
+      return this;
+    }
+  }, {
+    key: "apply",
+    value: function apply(type, thisArgument, argumentsList) {
+      var returnValue;
+      var rootOptions = _classPrivateFieldGet(_rootOptions, this);
+      var _ref = rootOptions || {},
+        rootEvent = _ref[type];
+      if (typeof rootEvent === 'function') {
+        // 最先调用根节点的事件
+        returnValue = Reflect.apply(rootEvent, thisArgument, argumentsList);
+      }
+      var _iterator = _createForOfIteratorHelper(this),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var options = _step.value;
+          if (options === rootOptions) {
+            continue;
+          }
+          var event = options[type];
+          if (typeof event !== 'function') {
+            continue;
+          }
+          // 非根节点事件，不处理返回值
+          Reflect.apply(event, thisArgument, argumentsList);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return returnValue;
+    }
+  }]);
+}(/*#__PURE__*/(0, _wrapNativeSuper2["default"])(Set));

package/lib/hooks/useContextValue/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useContextValue = void 0;
+var _ahooks = require("ahooks");
+var _Statuses = require("../../enums/Statuses");
+var useContextValue = exports.useContextValue = function useContextValue(store, reducers, optionsSet, statuses) {
+  var entity = store.value;
+  return (0, _ahooks.useCreation)(function () {
+    void entity;
+    if ((statuses & _Statuses.Statuses.EntityEnabled) === _Statuses.Statuses.EntityEnabled) {
+      return {
+        store: store,
+        reducers: reducers,
+        optionsSet: optionsSet,
+        statuses: statuses
+      };
+    }
+    return {
+      reducers: reducers,
+      statuses: statuses
+    };
+  }, [entity, store, reducers, optionsSet, statuses]);
+};

package/lib/hooks/useContextualItem/index.js

@@ -4,34 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useContextualItem = void 0;
-var _useDepsKey = require("../useDepsKey");
-var _ahooks = require("ahooks");
+var _useRootCreation = require("../useRootCreation");
 var _Statuses = require("../../enums/Statuses");
-var _methodUseCase2 = require("../../usecases/methodUseCase");
-var useContextualItem = exports.useContextualItem = function useContextualItem(contextItem, statuses, createFactory) {
+var useContextualItem = exports.useContextualItem = function useContextualItem(contextItem, statuses, callback) {
   var deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-  var depsKey = (0, _useDepsKey.useDepsKey)(deps);
-  var factoryRef = (0, _ahooks.useLatest)(createFactory);
-  var onCache = (0, _ahooks.useMemoizedFn)(function () {
-    var _methodUseCase = (0, _methodUseCase2.methodUseCase)(),
-      cacheCall = _methodUseCase.cacheCall;
-    var currentFactory = factoryRef.current;
-    // 防止在以下 `onCreate()` 多次调用实际 `factory`
-    return cacheCall(currentFactory, {
-      onCompare: function onCompare() {
-        return true;
-      }
-    });
-  });
-  var onCreate = (0, _ahooks.useCreation)(function () {
-    void depsKey;
-    return onCache();
-  }, [depsKey, onCache]);
-  return (0, _ahooks.useCreation)(function () {
-    var rootEnabled = (statuses & _Statuses.Statuses.RootEnabled) === _Statuses.Statuses.RootEnabled;
-    if (!rootEnabled && contextItem) {
-      return contextItem;
-    }
-    return onCreate();
-  }, [statuses, contextItem, onCreate]);
+  var rootEnabled = (statuses & _Statuses.Statuses.RootEnabled) === _Statuses.Statuses.RootEnabled;
+  var rootItem = (0, _useRootCreation.useRootCreation)(statuses, callback, false, deps);
+  if (rootEnabled) {
+    return rootItem;
+  }
+  return contextItem;
 };

package/lib/hooks/useEntity/index.js

@@ -14,11 +14,11 @@ var _react = require("react");
 var _Statuses = require("../../enums/Statuses");
 var _triggerWatchers = require("../../methods/triggerWatchers");
 var _lifecycleEventUseCase = require("../../usecases/lifecycleEventUseCase");
-var useEntity = exports.useEntity = function useEntity(store, statuses, options) {
+var useEntity = exports.useEntity = function useEntity(store, statuses, hookOptions) {
   var entity = store.value;
   var update = (0, _ahooks.useUpdate)();
   var isInitializing = (0, _useEntityInitializing.useEntityInitializing)(statuses);
-  var optionsRef = (0, _ahooks.useLatest)(options);
+  var hookOptionsRef = (0, _ahooks.useLatest)(hookOptions);
   var prevEntityRef = (0, _react.useRef)(entity);
   var entityEnabled = (statuses & _Statuses.Statuses.EntityEnabled) === _Statuses.Statuses.EntityEnabled;
   var entityRootEnabled = (statuses & _Statuses.Statuses.EntityRootEnabled) === _Statuses.Statuses.EntityRootEnabled;
@@ -34,7 +34,7 @@ var useEntity = exports.useEntity = function useEntity(store, statuses, options)
     return createKey();
   });
   var onTriggerWatchers = (0, _ahooks.useMemoizedFn)(function (newEntity, oldEntity) {
-    var watch = optionsRef.current.watch;
+    var watch = hookOptionsRef.current.watch;
     if (!watch) {
       return;
     }
@@ -51,14 +51,18 @@ var useEntity = exports.useEntity = function useEntity(store, statuses, options)
       return;
     }
     var _getLifecycleEvents = getLifecycleEvents(lifecycleKey),
-      onUpdate = _getLifecycleEvents.onUpdate;
+      onUpdate = _getLifecycleEvents.onUpdate,
+      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);
   });
   var onEntityChange = (0, _ahooks.useMemoizedFn)(function (newEntity, oldEntity) {
-    var currentOptions = optionsRef.current;
-    var onChange1 = currentOptions.onChange;
+    var currentHookOptions = hookOptionsRef.current;
+    var onChange1 = currentHookOptions.onChange;
     var _getLifecycleEvents2 = getLifecycleEvents(lifecycleKey),
       onChange2 = _getLifecycleEvents2.onChange;
     onEntityUpdate(newEntity, oldEntity);
@@ -74,12 +78,14 @@ var useEntity = exports.useEntity = function useEntity(store, statuses, options)
       return;
     }
     var _bindLifecycleEventsK = bindLifecycleEventsKey(lifecycleKey),
-      onBind = _bindLifecycleEventsK.onBind;
+      onBind = _bindLifecycleEventsK.onBind,
+      onAdopt = _bindLifecycleEventsK.onAdopt;
     if (!isInitializing) {
       return;
     }
     onBind === null || onBind === void 0 || onBind(entity);
-  });
+    onAdopt === null || onAdopt === void 0 || onAdopt(entity);
+  }, null, []);
   (0, _ahooks.useUnmount)(function () {
     if (!entityRootEnabled) {
       return;
@@ -87,9 +93,11 @@ var useEntity = exports.useEntity = function useEntity(store, statuses, options)
     // 要使用最新的 `entity`
     var currentEntity = store.value;
     var _getLifecycleEvents3 = getLifecycleEvents(lifecycleKey),
-      onUnbind = _getLifecycleEvents3.onUnbind;
+      onUnbind = _getLifecycleEvents3.onUnbind,
+      onDiscard = _getLifecycleEvents3.onDiscard;
     deleteLifecycleEvents(lifecycleKey);
     onUnbind === null || onUnbind === void 0 || onUnbind(currentEntity);
+    onDiscard === null || onDiscard === void 0 || onDiscard(currentEntity);
   });
   /**
    * 需要马上 `watch`，因为 `useEffect` 在子组件内优先执行，
@@ -100,14 +108,12 @@ var useEntity = exports.useEntity = function useEntity(store, statuses, options)
       return;
     }
     store.watch(onEntityChange);
-  }, [store, entityEnabled, onEntityChange]);
+  },
   /**
    * 在变化时候，组件更新前，使用 `unwatch`
    */
-  (0, _react.useEffect)(function () {
-    return function () {
-      store.unwatch(onEntityChange);
-    };
+  function () {
+    store.unwatch(onEntityChange);
   }, [store, entityEnabled, onEntityChange]);
   (0, _ahooks.useUpdateEffect)(function () {
     onEntityUpdate();

package/lib/hooks/useExec/index.js

@@ -6,14 +6,27 @@ Object.defineProperty(exports, "__esModule", {
 exports.useExec = void 0;
 var _useDepsKey = require("../useDepsKey");
 var _ahooks = require("ahooks");
-var useExec = exports.useExec = function useExec(callback) {
-  var deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [callback];
+var _react = require("react");
+var useExec = exports.useExec = function useExec(callback, destructor) {
+  var deps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [callback];
   var depsKey = (0, _useDepsKey.useDepsKey)(deps);
-  var execCallback = (0, _ahooks.useMemoizedFn)(function () {
+  var destructorRef = (0, _react.useRef)(null);
+  var onDestruct = function onDestruct() {
+    var _destructorRef$curren;
+    var isUnmount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    (_destructorRef$curren = destructorRef.current) === null || _destructorRef$curren === void 0 || _destructorRef$curren.call(destructorRef, isUnmount);
+  };
+  var onExec = (0, _ahooks.useMemoizedFn)(function () {
+    onDestruct();
+    // `destructor` 一定是在执行回调的时候，同步绑定的，保持两个回调内的闭包变量一致
+    destructorRef.current = destructor || null;
     return callback();
   });
+  (0, _ahooks.useUnmount)(function () {
+    onDestruct(true);
+  });
   return (0, _ahooks.useCreation)(function () {
     void depsKey;
-    return execCallback();
-  }, [depsKey, execCallback]);
+    return onExec();
+  }, [depsKey, onExec]);
 };

package/lib/hooks/useOptions/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOptions = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _useExec = require("../useExec");
+var _useRootCreation = require("../useRootCreation");
+var _Statuses = require("../../enums/Statuses");
+var _excluded = ["watch", "onChange"];
+var useOptions = exports.useOptions = function useOptions(options, optionsSet, statuses) {
+  var deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  var entityEnabled = (statuses & _Statuses.Statuses.EntityEnabled) === _Statuses.Statuses.EntityEnabled;
+  var entityRootEnabled = (statuses & _Statuses.Statuses.EntityRootEnabled) === _Statuses.Statuses.EntityRootEnabled;
+  var watch = options.watch,
+    onChange = options.onChange,
+    restOptions = (0, _objectWithoutProperties2["default"])(options, _excluded);
+  var _options$options = options.options,
+    propertyOptions = _options$options === void 0 ? restOptions : _options$options;
+  var contextualOptions = propertyOptions;
+  var hookOptions = entityEnabled ? {
+    watch: watch,
+    onChange: onChange
+  } : {};
+  var onProxyEvent = function onProxyEvent(propertyName) {
+    return new Proxy(function () {}, {
+      apply: function apply(fn, thisArgument, argumentList) {
+        return optionsSet.apply(propertyName, thisArgument, argumentList);
+      }
+    });
+  };
+  var onGet = function onGet(target, propertyName, receiver) {
+    var isStringProperty = typeof propertyName === 'string';
+    var isEvent = isStringProperty && /^on[A-Z]/.test(propertyName);
+    if (!isEvent) {
+      return Reflect.get(target, propertyName, receiver);
+    }
+    return onProxyEvent(propertyName);
+  };
+  var rootOptions = (0, _useRootCreation.useRootCreation)(statuses, function () {
+    return new Proxy(contextualOptions, {
+      get: onGet
+    });
+  }, true, deps);
+  var entityUseCaseOptions = rootOptions || contextualOptions;
+  var usecaseOptions = entityEnabled ? entityUseCaseOptions : options;
+  (0, _useExec.useExec)(function () {
+    if (!entityEnabled) {
+      return;
+    }
+    optionsSet.add(contextualOptions, entityRootEnabled);
+  }, function () {
+    optionsSet["delete"](contextualOptions);
+  });
+  return {
+    hookOptions: hookOptions,
+    usecaseOptions: usecaseOptions
+  };
+};

package/lib/hooks/useOptionsSet/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOptionsSet = void 0;
+var _useRootCreation = require("../useRootCreation");
+var _react = require("react");
+var _OptionsSet = require("../../classes/OptionsSet");
+var useOptionsSet = exports.useOptionsSet = function useOptionsSet(context, statuses) {
+  // 过滤掉三个特殊属性
+  var contextValue = (0, _react.useContext)(context);
+  var _ref = contextValue || {},
+    contextOptionsSet = _ref.optionsSet;
+  var rootEventsSet = (0, _useRootCreation.useRootCreation)(statuses, function () {
+    return new _OptionsSet.OptionsSet();
+  });
+  if (rootEventsSet) {
+    return rootEventsSet;
+  }
+  return contextOptionsSet;
+};

package/lib/hooks/useProvider/index.js

@@ -8,15 +8,7 @@ exports.useProvider = void 0;
 var _useConstantFn = require("../useConstantFn");
 var _ahooks = require("ahooks");
 var _react = _interopRequireDefault(require("react"));
-var _contextUseCase2 = require("../../usecases/contextUseCase");
-var useProvider = exports.useProvider = function useProvider(statuses, context, store, reducers) {
-  var entity = store.value;
-  var contextValue = (0, _ahooks.useCreation)(function () {
-    var _contextUseCase = (0, _contextUseCase2.contextUseCase)(),
-      createContextValue = _contextUseCase.createContextValue;
-    void entity;
-    return createContextValue(store, reducers, statuses);
-  }, [statuses, entity, store, reducers]);
+var useProvider = exports.useProvider = function useProvider(context, contextValue) {
   var contextValueRef = (0, _ahooks.useLatest)(contextValue);
   return (0, _useConstantFn.useConstantFn)(function (_ref) {
     var children = _ref.children,

package/lib/hooks/useReducers/index.js

@@ -1,53 +1,30 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useReducers = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
 var _useContextualItem = require("../useContextualItem");
 var _usecases = require("@mic-rexjs/usecases");
-var _ahooks = require("ahooks");
 var _react = require("react");
 var _Statuses = require("../../enums/Statuses");
-var _methodUseCase2 = require("../../usecases/methodUseCase");
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var _excluded = ["watch", "onChange", "options"];
-var useReducers = exports.useReducers = function useReducers(usecase, context, store, statuses, options) {
+var useReducers = exports.useReducers = function useReducers(usecase, store, context, statuses, usecaseOptions) {
   var deps = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
-  var optionsRef = (0, _ahooks.useLatest)(options);
   var contextValue = (0, _react.useContext)(context);
   var _ref = contextValue || {},
     _ref$reducers = _ref.reducers,
     contextReducers = _ref$reducers === void 0 ? null : _ref$reducers;
-  var entityRootEnabled = (statuses & _Statuses.Statuses.EntityRootEnabled) === _Statuses.Statuses.EntityRootEnabled;
+  var entityEnabled = (statuses & _Statuses.Statuses.EntityEnabled) === _Statuses.Statuses.EntityEnabled;
   var onCreate = function onCreate() {
-    var _methodUseCase = (0, _methodUseCase2.methodUseCase)(),
-      captureCalls = _methodUseCase.captureCalls;
-    var opts = captureCalls(options, function (key, callArgs) {
-      var _optionsRef$current$k2;
-      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$k2 = _optionsRef$current$k).call.apply(_optionsRef$current$k2, [_optionsRef$current].concat((0, _toConsumableArray2["default"])(callArgs)));
-    });
-    if (!entityRootEnabled) {
-      return usecase(opts);
+    if (!entityEnabled) {
+      return usecase(usecaseOptions);
     }
-    var hookOptions = opts;
-    var watch = hookOptions.watch,
-      onChange = hookOptions.onChange,
-      usecaseOptions = hookOptions.options,
-      restUseCaseOptions = (0, _objectWithoutProperties2["default"])(hookOptions, _excluded);
-    return (0, _usecases.createEntityReducers)(store, usecase, _objectSpread(_objectSpread(_objectSpread({}, restUseCaseOptions), usecaseOptions), {}, {
+    return (0, _usecases.createEntityReducers)(store, usecase, {
+      options: usecaseOptions,
       onGenerate: function onGenerate(newEntity, result) {
         return result;
       }
-    }));
+    });
   };
-  return (0, _useContextualItem.useContextualItem)(contextReducers, statuses, function () {
-    return onCreate();
-  }, deps);
+  return (0, _useContextualItem.useContextualItem)(contextReducers, statuses, onCreate, deps);
 };