@mic-rexjs/usecases-react 2.10.1 → 2.10.3

package/es/methods/triggerWatchers/index.js

@@ -1,14 +1,9 @@
-import { compareProperty } from '../compareProperty';
+import { valueUseCase } from '../../usecases/valueUseCase';
 export const triggerWatchers = (watch, newEntity, oldEntity) => {
+    const { matchProperty } = valueUseCase();
     for (const [fieldPath, watcher] of Object.entries(watch)) {
-        compareProperty(oldEntity, newEntity, fieldPath, (oldValue, newValue, fieldPaths) => {
-            watcher({
-                fieldPaths,
-                newEntity,
-                oldEntity,
-                newValue,
-                oldValue,
-            });
+        matchProperty(oldEntity, newEntity, fieldPath, (result) => {
+            watcher(result);
         });
     }
 };

package/es/types.d.ts

@@ -0,0 +1,3 @@
+import { RestArguments } from '@mic-rexjs/usecases/es/types';
+export interface Dependencies extends RestArguments {
+}

package/es/usecases/contextUseCase/index.js

@@ -1,6 +1,6 @@
 import { createUseCase } from '@mic-rexjs/usecases';
-import { ArgumentTypes } from '../../enums/ArgumentTypes';
 import { createContext } from 'react';
+import { ArgumentTypes } from '../../enums/ArgumentTypes';
 import { Statuses } from '../../enums/Statuses';
 export const contextUseCase = createUseCase(() => {
     const referenceMap = new Map();
@@ -18,7 +18,7 @@ export const contextUseCase = createUseCase(() => {
         };
         const getUseCaseContext = (usecase) => {
             if (!referenceMap.has(usecase)) {
-                return null;
+                return defaultUseCaseContext;
             }
             const { value } = referenceMap.get(usecase);
             return value;

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

@@ -1,8 +1,7 @@
-/// <reference types="react" />
-import { ArgumentTypes } from '../../enums/ArgumentTypes';
-import { Statuses } from '../../enums/Statuses';
 import { AsyncEntityGenerator, EntityGenerator, EntityReducer, EntityStore, ReducerKeys, Reducers } from '@mic-rexjs/usecases';
 import { EntityReducerMap, InferableUseCase, ReducerMap } from '@mic-rexjs/usecases/es/types';
+import { ArgumentTypes } from '../../enums/ArgumentTypes';
+import { Statuses } from '../../enums/Statuses';
 export type ContextualEntityReducer<T, TEntityReducer extends EntityReducer<T>> = TEntityReducer 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, TEntityReducers extends EntityReducerMap<T>> = {
     [K in ReducerKeys<TEntityReducers>]: ContextualEntityReducer<T, TEntityReducers[K]>;
@@ -22,7 +21,7 @@ export interface ContextReference<T> {
 }
 export type ContextReducers = Reducers<{
     createContextValue<T, TReducers extends ReducerMap>(store: EntityStore<T>, reducers: TReducers, statuses: Statuses): ContextValue<TReducers>;
-    getUseCaseContext<T extends ReducerMap, TUseCaseOptions extends object>(usecase: InferableUseCase<T, TUseCaseOptions>): Context<ContextValue<T>> | null;
+    getUseCaseContext<T extends ReducerMap, TUseCaseOptions extends object>(usecase: InferableUseCase<T, TUseCaseOptions>): Context<ContextValue<T>>;
     registerUseCase<T extends ReducerMap, TUseCaseOptions extends object>(usecase: InferableUseCase<T, TUseCaseOptions>, argumentTypes: ArgumentTypes): Context<ContextValue<T>>;
     unregisterUseCase<T extends ReducerMap, TUseCaseOptions extends object>(usecase: InferableUseCase<T, TUseCaseOptions>, argumentTypes: ArgumentTypes): boolean;
 }>;

package/es/usecases/methodUseCase/index.d.ts

@@ -0,0 +1,2 @@
+import { MethodReducers } from './types';
+export declare const methodUseCase: () => MethodReducers;

package/es/usecases/methodUseCase/index.js

@@ -0,0 +1,55 @@
+import { valueUseCase } from '../valueUseCase';
+export const methodUseCase = () => {
+    const { isValueMatched } = valueUseCase();
+    const cacheCall = (factory, options) => {
+        let cache;
+        const { onShouldCache = () => {
+            return true;
+        }, onCompare = (newArgs, oldArgs) => {
+            return isValueMatched(newArgs, oldArgs);
+        }, } = options || {};
+        return ((...args) => {
+            const cacheable = onShouldCache();
+            if (cache && cacheable) {
+                const { parameters, returnValue } = cache;
+                if (onCompare(parameters, args)) {
+                    return returnValue;
+                }
+            }
+            const returnValue = factory(...args);
+            if (cacheable) {
+                cache = {
+                    parameters: args,
+                    returnValue,
+                };
+            }
+            return returnValue;
+        });
+    };
+    const cacheCalls = (sourceFactories, options) => {
+        const cachedFactories = {};
+        Object.entries(sourceFactories).forEach(([key, factory]) => {
+            cachedFactories[key] = cacheCall(factory, options);
+        });
+        return cachedFactories;
+    };
+    const captureCalls = (obj, callback) => {
+        const newObj = {};
+        Object.keys(obj).forEach((key) => {
+            const value = obj[key];
+            if (typeof value === 'function') {
+                newObj[key] = ((...args) => {
+                    return callback(key, args);
+                });
+                return;
+            }
+            newObj[key] = value;
+        });
+        return newObj;
+    };
+    return {
+        cacheCall,
+        cacheCalls,
+        captureCalls,
+    };
+};

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

@@ -0,0 +1,21 @@
+import { Reducers } from '@mic-rexjs/usecases';
+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>;
+}
+export interface CaptureCallFactory {
+    <T>(key: string, args: RestArguments): T;
+}
+export type MethodReducers = Reducers<{
+    cacheCall<T extends CacheableFactory>(factory: T, options?: CacheCallOptions): T;
+    cacheCalls<T extends Record<string, CacheableFactory>>(sourceFactories: T, options?: CacheCallOptions): T;
+    captureCalls<T extends object>(obj: T, callback: CaptureCallFactory): T;
+}>;

package/es/usecases/valueUseCase/index.d.ts

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

package/es/usecases/valueUseCase/index.js

@@ -0,0 +1,136 @@
+import { createUseCase, entityUseCase } from '@mic-rexjs/usecases';
+export const valueUseCase = createUseCase(() => {
+    let keyIndex = 0;
+    return () => {
+        let prevKeyIndex = keyIndex++;
+        const entityReducers = entityUseCase();
+        const hasField = (entity, field) => {
+            if (typeof entity !== 'object' || entity === null) {
+                return false;
+            }
+            return Object.hasOwn(entity, field);
+        };
+        const isValueChanged = (entity, value) => {
+            return entity !== value;
+        };
+        const isValueMatched = (entity, value) => {
+            if (entity === value) {
+                return true;
+            }
+            const isObject1 = typeof entity === 'object' && entity !== null;
+            const isObject2 = typeof value === 'object' && value !== null;
+            if (!isObject1 || !isObject2) {
+                return false;
+            }
+            const keys1 = Object.keys(entity);
+            const keys2 = Object.keys(value);
+            const { length: length1 } = keys1;
+            const { length: length2 } = keys2;
+            if (length1 !== length2) {
+                return false;
+            }
+            for (const key of keys1) {
+                const value1 = entity[key];
+                const value2 = value[key];
+                if (value1 === value2) {
+                    continue;
+                }
+                return false;
+            }
+            return true;
+        };
+        const matchProperty = (entity, value, fieldPath, onFailed) => {
+            let allMatched = true;
+            let currentFieldPath = fieldPath;
+            const list = [
+                {
+                    fieldPaths: [],
+                    newEntity: value,
+                    newValue: value,
+                    oldEntity: entity,
+                    oldValue: entity,
+                },
+            ];
+            do {
+                const { oldValue, newValue, fieldPaths } = list.shift();
+                const [, key = currentFieldPath, subFieldPath = ''] = currentFieldPath.match(/^([^.]+)\.(.+)$/) || [];
+                const hasOldField = hasField(oldValue, key);
+                const hasNewField = hasField(newValue, key);
+                if (hasOldField || hasNewField) {
+                    const subOldValue = hasOldField ? oldValue[key] : void 0;
+                    const subNewValue = hasNewField ? newValue[key] : void 0;
+                    const result = {
+                        fieldPaths: [...fieldPaths, key],
+                        newEntity: value,
+                        newValue: subNewValue,
+                        oldEntity: entity,
+                        oldValue: subOldValue,
+                    };
+                    if (subFieldPath) {
+                        currentFieldPath = subFieldPath;
+                        list.push(result);
+                        continue;
+                    }
+                    if (subOldValue === subNewValue) {
+                        continue;
+                    }
+                    allMatched = false;
+                    onFailed?.(result);
+                    continue;
+                }
+                if (/^\d+^/.test(key)) {
+                    continue;
+                }
+                const oldArray = Array.isArray(oldValue) ? oldValue : [];
+                const newArray = Array.isArray(newValue) ? newValue : [];
+                const { length: oldLength } = oldArray;
+                const { length: newLength } = newArray;
+                const length = Math.max(oldLength, newLength);
+                for (let i = 0; i < length; i++) {
+                    list.push({
+                        fieldPaths: [...fieldPaths, `${i}`],
+                        newEntity: value,
+                        newValue: newArray[i],
+                        oldEntity: entity,
+                        oldValue: oldArray[i],
+                    });
+                }
+            } while (list.length > 0);
+            return allMatched;
+        };
+        const recordValue = function* (entity, value) {
+            const changed = isValueChanged(entity, value);
+            if (!changed) {
+                return false;
+            }
+            yield value;
+            return true;
+        };
+        const recordValueMatch = function* (entity, value) {
+            const matched = isValueMatched(entity, value);
+            if (matched) {
+                return true;
+            }
+            yield value;
+            return false;
+        };
+        const recordValueMatchWith = function* (entity, value, key = keyIndex + 1) {
+            const matched = yield* recordValueMatch(entity, value);
+            if (!matched) {
+                // 不管是不是使用 `keyIndex` 生成的 `key`，都自增一次，如果是，则可以保持一致
+                keyIndex++;
+                prevKeyIndex = key;
+            }
+            return prevKeyIndex;
+        };
+        return {
+            ...entityReducers,
+            isValueChanged,
+            isValueMatched,
+            matchProperty,
+            recordValue,
+            recordValueMatch,
+            recordValueMatchWith,
+        };
+    };
+});

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

@@ -0,0 +1,16 @@
+import { EntityGenerator, EntityReducers } from '@mic-rexjs/usecases';
+import { MatchPropertyFailedResult } from '../../entities/matchPropertyFailedResult/types';
+export interface MatchPropertyFailedCallback<T> {
+    (result: MatchPropertyFailedResult<T>): void;
+}
+export type ValueReducers<T> = EntityReducers<T, {
+    isValueChanged<S extends T>(entity: S, value: S): boolean;
+    isValueMatched<S extends T>(entity: S, value: S): boolean;
+    matchProperty<S extends T>(entity: S, value: S, fieldPath: string, onFailed?: MatchPropertyFailedCallback<S>): boolean;
+    recordValue<S extends T>(entity: S, value: S): EntityGenerator<S, boolean>;
+    recordValueMatch<S extends T>(entity: S, value: S): EntityGenerator<S, boolean>;
+    recordValueMatchWith<S extends T>(entity: S, value: S, key?: number): EntityGenerator<S, number>;
+}>;
+export interface ValueUseCase {
+    <T>(): ValueReducers<T>;
+}

package/es/usecases/valueUseCase/types.js

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

package/lib/components/SafeUseCaseFragment/index.js

@@ -7,9 +7,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.SafeUseCaseFragment = void 0;
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _jsxRuntime = require("react/jsx-runtime");
-var _react = require("react");
 var _useUseCase3 = require("../../hooks/useUseCase");
 var _ahooks = require("ahooks");
+var _react = require("react");
 var SafeUseCaseFragment = exports.SafeUseCaseFragment = function SafeUseCaseFragment(_ref) {
   var usecase = _ref.usecase,
     watch = _ref.watch,

package/lib/components/UseCaseFragment/index.js

@@ -8,10 +8,10 @@ exports.UseCaseFragment = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
 var _jsxRuntime = require("react/jsx-runtime");
-var _react = require("react");
 var _useUseCase2 = require("../../hooks/useUseCase");
-var _contextUseCase = require("../../usecases/contextUseCase");
 var _SafeUseCaseFragment = require("../SafeUseCaseFragment");
+var _react = require("react");
+var _contextUseCase = require("../../usecases/contextUseCase");
 var _excluded = ["usecase"];
 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; }
@@ -21,8 +21,9 @@ var UseCaseFragment = exports.UseCaseFragment = function UseCaseFragment(_ref) {
   var _useUseCase = (0, _useUseCase2.useUseCase)(_contextUseCase.contextUseCase),
     getUseCaseContext = _useUseCase.getUseCaseContext;
   var context = getUseCaseContext(usecase);
+  var contextValue = (0, _react.useContext)(context);
   return (0, _jsxRuntime.jsx)(_react.Fragment, {
-    children: context === null ? null : (0, _jsxRuntime.jsx)(_SafeUseCaseFragment.SafeUseCaseFragment, _objectSpread({
+    children: contextValue === null ? null : (0, _jsxRuntime.jsx)(_SafeUseCaseFragment.SafeUseCaseFragment, _objectSpread({
       usecase: usecase
     }, props))
   });

package/lib/hooks/useArgumentTypes/index.js

@@ -7,17 +7,16 @@ Object.defineProperty(exports, "__esModule", {
 exports.useArgumentTypes = void 0;
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _ArgumentTypes = require("../../enums/ArgumentTypes");
 var _useConstant = require("../useConstant");
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
 var useArgumentTypes = exports.useArgumentTypes = function useArgumentTypes(args) {
   return (0, _useConstant.useConstant)(function () {
-    var types = _ArgumentTypes.ArgumentTypes.None;
     var _args = (0, _slicedToArray2["default"])(args, 2),
       arg2 = _args[1];
     var type2 = (0, _typeof2["default"])(arg2);
     if (type2 === 'function') {
-      types |= _ArgumentTypes.ArgumentTypes.Entity;
+      return _ArgumentTypes.ArgumentTypes.Entity;
     }
-    return types;
+    return _ArgumentTypes.ArgumentTypes.None;
   });
 };

package/lib/hooks/useContext/index.test.js

@@ -2,11 +2,11 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _ = require(".");
 var _globals = require("@jest/globals");
 var _react = require("@testing-library/react");
-var _ = require(".");
-var _ArgumentTypes = require("../../enums/ArgumentTypes");
 var _react2 = require("react");
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
 var testUseCase = function testUseCase() {
   return {};
 };

package/lib/hooks/useContextualItem/index.js

@@ -4,25 +4,34 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useContextualItem = void 0;
+var _useReducers2 = require("../useReducers");
 var _ahooks = require("ahooks");
 var _Statuses = require("../../enums/Statuses");
-var _cacheCall = require("../../methods/cacheCall");
+var _methodUseCase = require("../../usecases/methodUseCase");
 var useContextualItem = exports.useContextualItem = function useContextualItem(contextItem, statuses, createFactory) {
   var depsKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
   var factoryRef = (0, _ahooks.useLatest)(createFactory);
-  var create = (0, _ahooks.useCreation)(function () {
+  var _useReducers = (0, _useReducers2.useReducers)(_methodUseCase.methodUseCase),
+    cacheCall = _useReducers.cacheCall;
+  var onCache = (0, _ahooks.useMemoizedFn)(function () {
+    var currentFactory = factoryRef.current;
     void depsKey;
-    return (0, _cacheCall.cacheCall)(factoryRef.current, {
+    // 防止在以下 `onCreate()` 多次调用实际 `factory`
+    return cacheCall(currentFactory, {
       onCompare: function onCompare() {
         return true;
       }
     });
-  }, [depsKey, factoryRef]);
+  });
+  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 create();
-  }, [statuses, contextItem, create]);
+    return onCreate();
+  }, [statuses, contextItem, onCreate]);
 };

package/lib/hooks/useDepsKey/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDepsKey = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _useEntityReducers2 = require("../useEntityReducers");
+var _valueUseCase = require("../../usecases/valueUseCase");
+var useDepsKey = exports.useDepsKey = function useDepsKey(deps) {
+  var _useEntityReducers = (0, _useEntityReducers2.useEntityReducers)(deps, _valueUseCase.valueUseCase),
+    recordValueMatchWith = _useEntityReducers.recordValueMatchWith;
+  var _recordValueMatchWith = recordValueMatchWith(deps),
+    _recordValueMatchWith2 = (0, _slicedToArray2["default"])(_recordValueMatchWith, 2),
+    depsKey = _recordValueMatchWith2[1];
+  return depsKey;
+};

package/lib/hooks/useEntity/index.js

@@ -4,16 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useEntity = void 0;
-var _react = require("react");
-var _usecases = require("@mic-rexjs/usecases");
-var _Statuses = require("../../enums/Statuses");
 var _useContextualItem = require("../useContextualItem");
+var _useRuntimeEntity = require("../useRuntimeEntity");
+var _usecases = require("@mic-rexjs/usecases");
 var _ahooks = require("ahooks");
+var _react = require("react");
+var _Statuses = require("../../enums/Statuses");
 var _triggerWatchers = require("../../methods/triggerWatchers");
-var _useRuntimeEntity = require("../useRuntimeEntity");
 var useEntity = exports.useEntity = function useEntity(statuses, entityArg, contextStore, options, depsKey) {
   var update = (0, _ahooks.useUpdate)();
-  var storeRef = (0, _react.useRef)();
+  var storeRef = (0, _react.useRef)(null);
   var optionsRef = (0, _ahooks.useLatest)(options);
   var contextEntity = contextStore ? contextStore.value : null;
   var entityEnabled = (statuses & _Statuses.Statuses.EntityEnabled) === _Statuses.Statuses.EntityEnabled;
@@ -47,7 +47,7 @@ var useEntity = exports.useEntity = function useEntity(statuses, entityArg, cont
   });
   if (entityRootEnabled) {
     // 执行同步操作
-    store.value = runtimeEntity;
+    store.setValue(runtimeEntity, true);
   }
   /**
    * 需要马上 `watch`，因为 `useEffect` 在子组件内优先执行，

package/lib/hooks/useEntityReducers/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useEntityReducers = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _useConstant2 = require("../useConstant");
+var _usecases = require("@mic-rexjs/usecases");
+var _ahooks = require("ahooks");
+var _valueUseCase = require("../../usecases/valueUseCase");
+var useEntityReducers = exports.useEntityReducers = function useEntityReducers(initailEntity, usecase, options) {
+  var deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  var _useConstant = (0, _useConstant2.useConstant)(function () {
+      return (0, _usecases.createEntityReducers)(deps, _valueUseCase.valueUseCase);
+    }),
+    recordValueMatchWith = _useConstant.recordValueMatchWith;
+  var _recordValueMatchWith = recordValueMatchWith(deps),
+    _recordValueMatchWith2 = (0, _slicedToArray2["default"])(_recordValueMatchWith, 2),
+    depsKey = _recordValueMatchWith2[1];
+  var onCreate = (0, _ahooks.useMemoizedFn)(function () {
+    return (0, _usecases.createEntityReducers)(initailEntity, usecase, options);
+  });
+  return (0, _ahooks.useCreation)(function () {
+    void depsKey;
+    void usecase;
+    return onCreate();
+  }, [depsKey, usecase, onCreate]);
+};

package/lib/hooks/useIsRenderingRef/index.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useIsRenderingRef = void 0;
+var _ahooks = require("ahooks");
 var _react = require("react");
 var useIsRenderingRef = exports.useIsRenderingRef = function useIsRenderingRef() {
-  var ref = (0, _react.useRef)(true);
-  ref.current = true;
+  var ref = (0, _ahooks.useLatest)(true);
   (0, _react.useEffect)(function () {
     ref.current = false;
   });

package/lib/hooks/useProvider/index.js

@@ -1,19 +1,17 @@
 "use strict";
 
-var _typeof = require("@babel/runtime/helpers/typeof");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useProvider = void 0;
-var _react = _interopRequireWildcard(require("react"));
-var _ahooks = require("ahooks");
 var _useConstantFn = require("../useConstantFn");
+var _ahooks = require("ahooks");
+var _react = _interopRequireDefault(require("react"));
 var _contextUseCase2 = require("../../usecases/contextUseCase");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
 var useProvider = exports.useProvider = function useProvider(statuses, context, store, reducers) {
   var entity = store.value;
-  var contextValue = (0, _react.useMemo)(function () {
+  var contextValue = (0, _ahooks.useCreation)(function () {
     var _contextUseCase = (0, _contextUseCase2.contextUseCase)(),
       createContextValue = _contextUseCase.createContextValue;
     void entity;

package/lib/hooks/useReducers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useReducers = void 0;
+var _useDepsKey = require("../useDepsKey");
+var _ahooks = require("ahooks");
+var useReducers = exports.useReducers = function useReducers(usecase, options) {
+  var deps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var depsKey = (0, _useDepsKey.useDepsKey)(deps);
+  var onCreate = (0, _ahooks.useMemoizedFn)(function () {
+    return usecase(options);
+  });
+  return (0, _ahooks.useCreation)(function () {
+    void depsKey;
+    void usecase;
+    return onCreate();
+  }, [depsKey, usecase, onCreate]);
+};

package/lib/hooks/useRuntimeEntity/index.js

@@ -4,21 +4,24 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useRuntimeEntity = void 0;
+var _useEntityReducers2 = require("../useEntityReducers");
 var _Statuses = require("../../enums/Statuses");
-var _react = require("react");
+var _valueUseCase = require("../../usecases/valueUseCase");
 var useRuntimeEntity = exports.useRuntimeEntity = function useRuntimeEntity(store, entityArg, contextEntity, statuses) {
-  var prevEntityArgRef = (0, _react.useRef)(entityArg);
+  var _useEntityReducers = (0, _useEntityReducers2.useEntityReducers)(entityArg, _valueUseCase.valueUseCase),
+    isValueChanged = _useEntityReducers.isValueChanged,
+    recordValue = _useEntityReducers.recordValue;
+  var changed = isValueChanged(entityArg);
   var entityRootDisabled = (statuses & _Statuses.Statuses.EntityRootEnabled) !== _Statuses.Statuses.EntityRootEnabled;
   if (entityRootDisabled) {
     return contextEntity;
   }
   var isFunction = typeof entityArg === 'function';
-  var prevEntityArg = prevEntityArgRef.current;
   switch (true) {
     case isFunction:
-    case prevEntityArg === entityArg:
+    case !changed:
       return store.value;
   }
-  prevEntityArgRef.current = entityArg;
+  recordValue(entityArg);
   return entityArg;
 };

package/lib/hooks/useStatuses/index.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useStatuses = void 0;
+var _ahooks = require("ahooks");
 var _ArgumentTypes = require("../../enums/ArgumentTypes");
 var _Statuses = require("../../enums/Statuses");
-var _ahooks = require("ahooks");
 var useStatuses = exports.useStatuses = function useStatuses(argumentTypes, contextValue) {
   return (0, _ahooks.useCreation)(function () {
     var statuses = _Statuses.Statuses.None;