@mic-rexjs/usecases-react 2.10.2 → 2.11.0

package/es/hooks/useUseCase/index.test.js

@@ -1,8 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { objectUseCase, entityUseCase, } from '@mic-rexjs/usecases';
-import { beforeEach, describe, expect, jest, test } from '@jest/globals';
-import { renderHook, act, render, fireEvent, screen } from '@testing-library/react';
 import { useUseCase } from '.';
+import { useDepsKey } from '../useDepsKey';
+import { beforeEach, describe, expect, jest, test } from '@jest/globals';
+import { entityUseCase, objectUseCase, } from '@mic-rexjs/usecases';
+import { fireEvent, screen } from '@testing-library/dom';
+import { act, render, renderHook } from '@testing-library/react';
 import { useDeepCompareEffect, useMemoizedFn, useMount, useUpdate, useUpdateEffect } from 'ahooks';
 import { Fragment, useEffect, useMemo, useRef, useState } from 'react';
 const EXT_1 = '.png';
@@ -110,17 +112,19 @@ const MathParent = ({ extraValue = 0, onUpdate }) => {
 };
 const useDeepCompareUpdate = (callback, deps) => {
     const isFirstRef = useRef(true);
+    const memoizedCallback = useMemoizedFn(callback);
+    const depsKey = useDepsKey(deps);
     useEffect(() => {
         return () => {
             isFirstRef.current = false;
         };
     });
-    useDeepCompareEffect.call(null, () => {
+    useDeepCompareEffect(() => {
         if (isFirstRef.current) {
             return;
         }
-        callback();
-    }, deps);
+        memoizedCallback();
+    }, [depsKey, memoizedCallback]);
 };
 beforeEach(() => {
     subtractionReducer.mockClear();
@@ -189,6 +193,66 @@ describe('useUseCase', () => {
             const { current: [currentFile], } = result;
             expect(currentFile).toEqual(file);
         });
+        test('Entity getter should provide the current entity', () => {
+            let updateIndex = 0;
+            const file = defaultFile;
+            const onFile = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase((currentFile) => {
+                    onFile(currentFile);
+                    return currentFile ?? file;
+                }, fileUseCase, {}, [updateIndex++]);
+            });
+            const { current: [, { setPath: setPath1 }], } = result;
+            expect(onFile).toHaveBeenCalledTimes(1);
+            expect(onFile).toHaveBeenCalledWith(void 0);
+            act(() => {
+                setPath1(PATH_1);
+            });
+            const { current: [, { setPath: setPath2 }], } = result;
+            expect(onFile).toHaveBeenCalledTimes(2);
+            expect(onFile).toHaveBeenCalledWith({ ...file, ext: EXT_1, path: PATH_1 });
+            act(() => {
+                setPath2(PATH_2);
+            });
+            expect(onFile).toHaveBeenCalledTimes(3);
+            expect(onFile).toHaveBeenCalledWith({ ...file, ext: EXT_2, path: PATH_2 });
+        });
+        test('Entity getter should provide the changed deps', () => {
+            let updateIndex = 0;
+            const file = defaultFile;
+            const symbol = Symbol('changedDep');
+            const onChangedDeps = jest.fn();
+            const { result } = renderHook(() => {
+                return useUseCase((currentFile = file, changedDeps) => {
+                    // 验证参数类型
+                    const [index1, num1, index2, string1, index3, boolean1] = changedDeps;
+                    const a = index1;
+                    const b = num1;
+                    const c = index2;
+                    const d = string1;
+                    const e = index3;
+                    const f = boolean1;
+                    void a;
+                    void b;
+                    void c;
+                    void d;
+                    void e;
+                    void f;
+                    // 先 `fill` 填充，再合并，以 `symbol` 代替虚无项去匹配
+                    onChangedDeps(Object.assign([...changedDeps].fill(symbol), changedDeps));
+                    return currentFile;
+                }, fileUseCase, {}, [updateIndex++, 0, updateIndex++, 'xyz', updateIndex++, false]);
+            });
+            const { current: [, { setPath: setPath }], } = result;
+            expect(onChangedDeps).toHaveBeenCalledTimes(1);
+            expect(onChangedDeps).toHaveBeenCalledWith([symbol, symbol, symbol, symbol, symbol, symbol]);
+            act(() => {
+                setPath(PATH_1);
+            });
+            expect(onChangedDeps).toHaveBeenCalledTimes(2);
+            expect(onChangedDeps).toHaveBeenCalledWith([3, symbol, 4, symbol, 5, symbol]);
+        });
         test('Entity property getter should always return the same object if nothing changed after component update', () => {
             let updateTimes = 0;
             const data = {

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

@@ -1,7 +1,9 @@
-import { UseCase } from '@mic-rexjs/usecases';
 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 { MatchPropertyFailedResult } from '../../entities/matchPropertyFailedResult/types';
+import { Dependencies } from '../../types';
 import { ContextualEntityReducers } from '../../usecases/contextUseCase/types';
-import { EntityReducerMap, EntityReducers, InferableEntityUseCase, ReducerMap, SymbolSet, SymbolSetTarget } from '@mic-rexjs/usecases/es/types';
 export interface NonEntitySymbolSet extends SymbolSet {
     entity?: never;
 }
@@ -15,15 +17,10 @@ export type ContextualCoreCollection<T, TEntityReducers extends EntityReducerMap
     reducers: ContextualEntityReducers<T, TEntityReducers>
 ];
 export type CoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = RootCoreCollection<T, TEntityReducers> | ContextualCoreCollection<T, TEntityReducers>;
-export interface EntityGetter<T> {
-    (entity?: T): T;
+export interface EntityGetter<T, TDependencies extends Dependencies = Dependencies> {
+    (entity: T | undefined, changedDeps: TDependencies): T;
 }
-export interface EntityWatchEvent<T, TValue = unknown> {
-    fieldPaths: string[];
-    newEntity: T;
-    newValue: TValue;
-    oldEntity: T;
-    oldValue: TValue;
+export interface EntityWatchEvent<T, TValue = unknown> extends MatchPropertyFailedResult<T, TValue> {
 }
 export interface EntityWatcher<T, TValue = unknown> {
     (event: EntityWatchEvent<T, TValue>): void;
@@ -31,9 +28,9 @@ export interface EntityWatcher<T, TValue = unknown> {
 export type PathTemplate = '1.2.3';
 export type NextPathTemplate<T extends string> = T extends `${string}.${infer U}` ? U : T;
 export type PropertyPath<T, TTemplate extends string, K extends keyof T = keyof T & string> = TTemplate extends `${string}.${string}` ? K extends infer TKey ? `${TKey & (string | number)}${'' | DotAccessorFieldPath<T[TKey & keyof T], TTemplate>}` : never : never;
-export type DotAccessorFieldPath<T, TTemplate extends string> = TTemplate extends `${string}.${string}` ? T extends unknown[] ? '.length' | `${'' | `.${number}`}${DotAccessorFieldPath<T[number], NextPathTemplate<TTemplate>>}` : T extends object ? `.${PropertyPath<T, NextPathTemplate<TTemplate>>}` : '' : '';
-export type FieldPath<T, TTemplate extends string = PathTemplate> = TTemplate extends `${string}.${string}` ? T extends unknown[] ? FieldPath<T[number], NextPathTemplate<TTemplate>> | 'length' : T extends object ? PropertyPath<T, TTemplate> : never : never;
-export type ExtractPropertyType<T, TPath> = TPath extends `${infer TKey}.${infer TSubPath}` ? T extends unknown[] ? ExtractPropertyType<T[number], TKey extends `${number}` ? TSubPath : TPath> : ExtractPropertyType<T[TKey & keyof T], TSubPath> : T extends unknown[] ? TPath extends 'length' ? T[TPath] : TPath extends `${number}` ? T[number] : ExtractPropertyType<T[number], TPath> : T[TPath & keyof T];
+export type DotAccessorFieldPath<T, TTemplate extends string> = TTemplate extends `${string}.${string}` ? T extends RestArguments ? '.length' | `${'' | `.${number}`}${DotAccessorFieldPath<T[number], NextPathTemplate<TTemplate>>}` : T extends object ? `.${PropertyPath<T, NextPathTemplate<TTemplate>>}` : '' : '';
+export type FieldPath<T, TTemplate extends string = PathTemplate> = TTemplate extends `${string}.${string}` ? T extends RestArguments ? FieldPath<T[number], NextPathTemplate<TTemplate>> | 'length' : T extends object ? PropertyPath<T, TTemplate> : never : never;
+export type ExtractPropertyType<T, TPath> = TPath extends `${infer TKey}.${infer TSubPath}` ? T extends RestArguments ? ExtractPropertyType<T[number], TKey extends `${number}` ? TSubPath : TPath> : ExtractPropertyType<T[TKey & keyof T], TSubPath> : T extends RestArguments ? TPath extends 'length' ? T[TPath] : TPath extends `${number}` ? T[number] : ExtractPropertyType<T[number], TPath> : T[TPath & keyof T];
 export type ExtractFieldType<T, TPath> = TPath extends `${infer TKey}.${infer TSubProperty}` ? ExtractPropertyType<T[TKey & keyof T], TSubProperty> : T[TPath & keyof T];
 export type EntityWatchMap<T> = {
     [K in FieldPath<T>]?: EntityWatcher<T, ExtractFieldType<T, K>>;
@@ -51,13 +48,13 @@ export type UnextendOptionTypes<T> = {
 };
 export type UseCaseHookOptions<T, TUseCaseOptions extends object = object> = UnextendOptionTypes<TUseCaseOptions> & UseCaseHookOwnOptions<T, TUseCaseOptions>;
 export interface ReducersHook {
-    <T extends ReducerMap, TUseCaseOptions extends object = object>(usecase: UseCase<T & SymbolSetTarget<NonEntitySymbolSet>, TUseCaseOptions>, options?: TUseCaseOptions, deps?: unknown[]): T;
+    <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?: unknown[]): ContextualCoreCollection<T, TEntityReducers>;
+    <T, TEntityReducers extends EntityReducerMap<T>>(usecase: InferableEntityUseCase<T, TEntityReducers>, options?: UseCaseHookContextualOptions<T>, deps?: Dependencies): ContextualCoreCollection<T, TEntityReducers>;
 }
 export interface RootCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object>(entity: T | EntityGetter<T>, usecase: InferableEntityUseCase<T, TEntityReducers & EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): RootCoreCollection<T, EntityReducers<T, TEntityReducers>>;
+    <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object, TDependencies extends Dependencies = Dependencies>(entity: T | EntityGetter<T, TDependencies>, usecase: InferableEntityUseCase<T, TEntityReducers & EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: TDependencies): RootCoreCollection<T, EntityReducers<T, TEntityReducers>>;
 }
 export interface CoreCollectionHook extends ContextualCoreCollectionHook, RootCoreCollectionHook {
 }

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();

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]>;

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,172 @@
+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, onMatchFailed) => {
+            if (entity === value) {
+                return true;
+            }
+            const isObject1 = typeof entity === 'object' && entity !== null;
+            const isObject2 = typeof value === 'object' && value !== null;
+            if (!isObject1 || !isObject2) {
+                return false;
+            }
+            let allMatched = true;
+            const keys1 = Object.keys(entity);
+            const keys2 = Object.keys(value);
+            const { length: length1 } = keys1;
+            const keys = [...keys1, ...keys2];
+            const hasCallback = typeof onMatchFailed === 'function';
+            for (let i = 0, { length } = keys; i < length; i++) {
+                const key = keys[i];
+                const isFromKeys2 = i >= length1;
+                const isInKey1 = keys1.includes(key);
+                const isUsed = isFromKeys2 && isInKey1;
+                if (isUsed) {
+                    continue;
+                }
+                const hasField1 = Object.hasOwn(entity, key);
+                const hasField2 = Object.hasOwn(value, key);
+                const onlyHasField1 = hasField1 && !hasField2;
+                const onlyHasField2 = !hasField1 && hasField2;
+                const onlyHasOneField = onlyHasField1 || onlyHasField2;
+                const value1 = entity[key];
+                const value2 = value[key];
+                const matched = value1 === value2;
+                if (!onlyHasOneField && matched) {
+                    continue;
+                }
+                allMatched = false;
+                if (hasCallback) {
+                    onMatchFailed(key, value2, value1);
+                    continue;
+                }
+                break;
+            }
+            return allMatched;
+        };
+        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 recordValueDiff = function* (entity, value) {
+            const isArray1 = Array.isArray(entity);
+            const isArray2 = Array.isArray(value);
+            const isArray = isArray1 && isArray2;
+            const result = (isArray ? [] : {});
+            if (isArray) {
+                const { length: length1 } = entity;
+                const { length: length2 } = value;
+                result.length = Math.max(length1, length2);
+            }
+            const matched = isValueMatched(entity, value, (key, newValue) => {
+                result[key] = newValue;
+            });
+            if (!matched) {
+                yield value;
+            }
+            return result;
+        };
+        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,
+            recordValueDiff,
+            recordValueMatch,
+            recordValueMatchWith,
+        };
+    };
+});

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

@@ -0,0 +1,20 @@
+import { EntityGenerator, EntityReducers } from '@mic-rexjs/usecases';
+import { MatchPropertyFailedResult } from '../../entities/matchPropertyFailedResult/types';
+export interface MatchPropertyFailedCallback<T> {
+    (result: MatchPropertyFailedResult<T>): void;
+}
+export interface MatchValueFailedCallback<T> {
+    <K extends keyof T>(key: K, newValue: T[K], oldValue: T[K]): void;
+}
+export type ValueReducers<T> = EntityReducers<T, {
+    isValueChanged<S extends T>(entity: S, value: S): boolean;
+    isValueMatched<S extends T>(entity: S, value: S, onMatchFailed?: MatchValueFailedCallback<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>;
+    recordValueDiff<S extends T>(entity: S, value: S): EntityGenerator<S, Partial<S>>;
+    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; }

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/useConstantEntityReducers/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConstantEntityReducers = void 0;
+var _useConstant = require("../useConstant");
+var _usecases = require("@mic-rexjs/usecases");
+var useConstantEntityReducers = exports.useConstantEntityReducers = function useConstantEntityReducers(initailEntity, usecase, options) {
+  return (0, _useConstant.useConstant)(function () {
+    return (0, _usecases.createEntityReducers)(initailEntity, usecase, options);
+  });
+};

package/lib/hooks/useConstantReducers/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConstantReducers = void 0;
+var _useConstant = require("../useConstant");
+var useConstantReducers = exports.useConstantReducers = function useConstantReducers(usecase, options) {
+  return (0, _useConstant.useConstant)(function () {
+    return usecase(options);
+  });
+};

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,36 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useContextualItem = void 0;
+var _useConstantReducers2 = require("../useConstantReducers");
+var _useDepsKey = require("../useDepsKey");
 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 deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  var depsKey = (0, _useDepsKey.useDepsKey)(deps);
   var factoryRef = (0, _ahooks.useLatest)(createFactory);
-  var create = (0, _ahooks.useCreation)(function () {
+  var _useConstantReducers = (0, _useConstantReducers2.useConstantReducers)(_methodUseCase.methodUseCase),
+    cacheCall = _useConstantReducers.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 _useConstantEntityReducers = require("../useConstantEntityReducers");
+var _valueUseCase = require("../../usecases/valueUseCase");
+var useDepsKey = exports.useDepsKey = function useDepsKey(deps) {
+  var _useConstantEntityRed = (0, _useConstantEntityReducers.useConstantEntityReducers)(deps, _valueUseCase.valueUseCase),
+    recordValueMatchWith = _useConstantEntityRed.recordValueMatchWith;
+  var _recordValueMatchWith = recordValueMatchWith(deps),
+    _recordValueMatchWith2 = (0, _slicedToArray2["default"])(_recordValueMatchWith, 2),
+    depsKey = _recordValueMatchWith2[1];
+  return depsKey;
+};