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

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

@@ -20,8 +20,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 +35,23 @@ 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> {
+    /**
+     * 触发机制包括以下两点：
+     *
+     * 1. 由相关 `reducers` 的调用行为触发 - 非渲染阶段；
+     * 2. 由 `useUseCase(entity, usecase)` 中的 `entity` 变化触发 - 渲染阶段。
+     */
     watch?: EntityWatchMap<T>;
+    /**
+     * 非渲染阶段触发，随后会触发组件的更新：
+     *
+     * 只由相关 `reducers` 的调用行为触发；
+     * 不包括 `useUseCase(entity, usecase)` 中的 `entity` 变化触发。
+     */
     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 +63,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?: ContextualUseCaseHookOptions<T>): 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/types.d.ts

@@ -1,6 +1,7 @@
-import { AsyncEntityCallbackGenerator, EntityGenerator, RestArguments } from '@mic-rexjs/usecases/es/types';
+import { AsyncEntityCallbackGenerator, EntityGenerator, EntityReducerMap, ReducerMap, RestArguments } from '@mic-rexjs/usecases/es/types';
 export interface Dependencies extends RestArguments {
 }
+export type UnknownReducerMap<T> = ReducerMap | EntityReducerMap<T>;
 export type InitEntityResult<T> = T | EntityGenerator<T> | AsyncEntityCallbackGenerator<T>;
 export interface EntityInitializer<T> {
     (entity: T | undefined): InitEntityResult<T>;

package/es/usecases/contextUseCase/index.js

@@ -1,67 +1,51 @@
 import { createUseCase } from '@mic-rexjs/usecases';
 import { createContext } from 'react';
-import { ArgumentTypes } from '../../enums/ArgumentTypes';
-import { Statuses } from '../../enums/Statuses';
 export const contextUseCase = createUseCase(() => {
   const referenceMap = new Map();
-  const defaultUseCaseContext = createContext(null);
   return () => {
-    const createContextValue = (store, reducers, statuses) => {
-      if ((statuses & Statuses.EntityEnabled) === Statuses.EntityEnabled) {
-        return {
-          store,
-          reducers,
-          statuses
-        };
-      }
-      return {
-        reducers,
-        statuses
-      };
+    const getTypedReferenceMap = () => {
+      return referenceMap;
     };
-    const getUseCaseContext = usecase => {
-      if (!referenceMap.has(usecase)) {
-        return defaultUseCaseContext;
+    const getContext = usecase => {
+      const map = getTypedReferenceMap();
+      if (!map.has(usecase)) {
+        return createContext(null);
       }
-      const _referenceMap$get = referenceMap.get(usecase),
-        value = _referenceMap$get.value;
+      const _map$get = map.get(usecase),
+        value = _map$get.value;
       return value;
     };
-    const registerUseCase = (usecase, argumentTypes) => {
-      if (referenceMap.has(usecase)) {
-        const reference = referenceMap.get(usecase);
+    const registerUseCase = usecase => {
+      const map = getTypedReferenceMap();
+      if (map.has(usecase)) {
+        const reference = map.get(usecase);
         const value = reference.value,
           times = reference.times;
-        referenceMap.set(usecase, {
+        map.set(usecase, {
           value,
           times: times + 1
         });
         return value;
       }
-      if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
-        return defaultUseCaseContext;
-      }
       const context = createContext(null);
-      referenceMap.set(usecase, {
+      map.set(usecase, {
         value: context,
         times: 1
       });
       return context;
     };
-    const unregisterUseCase = (usecase, argumentTypes) => {
-      if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
-        return false;
-      }
-      if (!referenceMap.has(usecase)) {
+    const unregisterUseCase = usecase => {
+      const map = getTypedReferenceMap();
+      if (!map.has(usecase)) {
         return false;
       }
-      const reference = referenceMap.get(usecase);
+      const reference = map.get(usecase);
       const value = reference.value,
         times = reference.times;
       if (times === 1) {
-        referenceMap.delete(usecase);
+        map.delete(usecase);
       } else {
-        referenceMap.set(usecase, {
+        map.set(usecase, {
           value,
           times: times - 1
         });
@@ -69,8 +53,7 @@ export const contextUseCase = createUseCase(() => {
       return true;
     };
     return {
-      createContextValue,
-      getUseCaseContext,
+      getContext,
       registerUseCase,
       unregisterUseCase
     };

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

@@ -1,8 +1,8 @@
 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 { EntityReducerMap, EntityUseCase, ReducerMap } from '@mic-rexjs/usecases/es/types';
 import { Statuses } from '../../enums/Statuses';
 export interface UseCaseContextValue<T extends ReducerMap> {
+    key: React.Key;
     reducers: T;
     statuses: Statuses;
 }
@@ -20,10 +20,9 @@ export type ContextualEntityReducers<T, TEntityReducers extends EntityReducerMap
     [K in ReducerKeys<TEntityReducers>]: ContextualEntityReducer<T, TEntityReducers[K]>;
 };
 export type ContextReducers = Reducers<{
-    createContextValue<T, TReducers extends ReducerMap>(store: EntityStore<T>, reducers: TReducers, statuses: Statuses): UseCaseContextValue<TReducers>;
-    getUseCaseContext<T extends ReducerMap, TUseCaseOptions extends object>(usecase: InferableUseCase<T, TUseCaseOptions>): UseCaseContext<UseCaseContextValue<T>>;
-    registerUseCase<T extends ReducerMap, TUseCaseOptions extends object>(usecase: InferableUseCase<T, TUseCaseOptions>, argumentTypes: ArgumentTypes): UseCaseContext<UseCaseContextValue<T>>;
-    unregisterUseCase<T extends ReducerMap, TUseCaseOptions extends object>(usecase: InferableUseCase<T, TUseCaseOptions>, argumentTypes: ArgumentTypes): boolean;
+    getContext<T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>): UseCaseContext<EntityUseCaseContextValue<T, TEntityReducers>>;
+    registerUseCase<T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>): UseCaseContext<EntityUseCaseContextValue<T, TEntityReducers>>;
+    unregisterUseCase<T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>): boolean;
 }>;
 export interface ContextUseCase {
     (): ContextReducers;

package/es/usecases/lifecycleEventUseCase/index.js

@@ -1,30 +1,58 @@
-import { createUseCase } from '@mic-rexjs/usecases';
+import { createUseCase, utilsUseCase } from '@mic-rexjs/usecases';
 export const lifecycleEventUseCase = createUseCase(() => {
   const map = new Map();
-  let events = null;
+  const eventsList = [];
+  const _utilsUseCase = utilsUseCase(),
+    createKey = _utilsUseCase.createKey;
   /**
    * 逻辑是：先存，再绑定 `key`，再通过 `key` 获取，最后清除
    */
   return () => {
+    const createLifecycleKey = () => {
+      return createKey();
+    };
     const deleteLifecycleEvents = key => {
       return map.delete(key);
     };
     const bindLifecycleEventsKey = key => {
-      if (events === null) {
+      const length = eventsList.length;
+      if (length === 0) {
         return {};
       }
-      const currentEvents = events;
-      events = null;
-      map.set(key, currentEvents);
-      return currentEvents;
+      const list = eventsList.splice(0);
+      const onEvent = (propertyKey, args) => {
+        let returnValue = void 0;
+        for (const events of list) {
+          const event = events[propertyKey];
+          if (typeof event !== 'function') {
+            continue;
+          }
+          returnValue !== null && returnValue !== void 0 ? returnValue : returnValue = Reflect.apply(event, null, args);
+        }
+        return returnValue;
+      };
+      const types = ['onBind', 'onUnbind', 'onAdopt', 'onDiscard', 'onChange', 'onUpdate'];
+      const entries = types.map(type => {
+        const event = function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          return onEvent(type, args);
+        };
+        return [type, event];
+      });
+      const events = Object.fromEntries(entries);
+      map.set(key, events);
+      return events;
     };
     const getLifecycleEvents = key => {
       return map.get(key) || {};
     };
-    const setLifecycleEvents = e => {
-      events = e;
+    const setLifecycleEvents = events => {
+      eventsList.push(events);
     };
     return {
+      createLifecycleKey,
       deleteLifecycleEvents,
       setLifecycleEvents,
       getLifecycleEvents,

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

@@ -17,13 +17,22 @@ export interface LifecycleEvents<T = unknown> {
      * 2. `onUpdate` 或 `onChange` 的时候。
      */
     onAdopt(newEntity: T, oldEntity?: T): void;
+    /**
+     * 当 `entity` 被废弃时候调用，包括以下两种情况：
+     *
+     * 1. `onUpdate` 或 `onChange` 的时候；
+     * 2. `onUnbind` 的时候。
+     */
+    onDiscard(entity: T): void;
     /**
      * 非渲染阶段触发，随后会触发组件的更新：
      *
      * 只由相关 `reducers` 的调用行为触发；
      * 不包括 `useUseCase(entity, usecase)` 中的 `entity` 变化触发。
+     *
+     * @returns 返回一个布尔值，决定是否跳过组件更新。
      */
-    onChange(newEntity: T, oldEntity: T): void;
+    onChange(newEntity: T, oldEntity: T): void | number | boolean | Promise<boolean>;
     /**
      * 触发机制包括以下两点：
      *
@@ -31,18 +40,12 @@ 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;
 }
 export type LifecycleEventReducers = Reducers<{
+    createLifecycleKey(): React.Key;
     deleteLifecycleEvents(key: React.Key): boolean;
     bindLifecycleEventsKey<T>(key: React.Key): Partial<LifecycleEvents<T>>;
     setLifecycleEvents<T>(events: Partial<LifecycleEvents<T>>): void;

package/lib/components/UseCaseFragment/index.js

@@ -19,8 +19,8 @@ var UseCaseFragment = exports.UseCaseFragment = function UseCaseFragment(_ref) {
   var usecase = _ref.usecase,
     props = (0, _objectWithoutProperties2["default"])(_ref, _excluded);
   var _useUseCase = (0, _useUseCase2.useUseCase)(_contextUseCase.contextUseCase),
-    getUseCaseContext = _useUseCase.getUseCaseContext;
-  var context = getUseCaseContext(usecase);
+    getContext = _useUseCase.getContext;
+  var context = getContext(usecase);
   var contextValue = (0, _react.useContext)(context);
   return (0, _jsxRuntime.jsx)(_react.Fragment, {
     children: contextValue === null ? null : (0, _jsxRuntime.jsx)(_SafeUseCaseFragment.SafeUseCaseFragment, _objectSpread({

package/lib/enums/Statuses/index.js

@@ -8,23 +8,99 @@ var Statuses;
 (function (Statuses) {
   Statuses[Statuses["None"] = 0] = "None";
   /**
-   * 是否需要初始化根 `redurcers`
+   * 是否启用 `entity`
    */
-  Statuses[Statuses["RootEnabled"] = 2] = "RootEnabled";
+  Statuses[Statuses["Entity"] = 4] = "Entity";
   /**
-   * 是否为上下文模式
+   * 是否以 `ReducersHook` 或 `RootCoreCollectionHook` 的形式被调用
    */
-  Statuses[Statuses["ContextEnabled"] = 4] = "ContextEnabled";
+  Statuses[Statuses["RootRuntime"] = 8] = "RootRuntime";
   /**
-   * 是否有 `entity`
+   * 是否以 `RootCoreCollectionHook` 的形式被调用
    */
-  Statuses[Statuses["EntityEnabled"] = 8] = "EntityEnabled";
+  Statuses[Statuses["EntityRootRuntime"] = 12] = "EntityRootRuntime";
   /**
-   * 是否为需要提供 `Provider` 去挂载根 `context`
+   * 是否以 `ContextualCoreCollectionHook` 的形式被调用
    */
-  Statuses[Statuses["ContextRootEnabled"] = 6] = "ContextRootEnabled";
+  Statuses[Statuses["EntityContextRuntime"] = 20] = "EntityContextRuntime";
   /**
-   * 是否初始化与 `entity` 相关的 `reducers`
+   * 当传入的 `entity` 参数变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个。
    */
-  Statuses[Statuses["EntityRootEnabled"] = 14] = "EntityRootEnabled";
+  Statuses[Statuses["InitialEntityX"] = 32] = "InitialEntityX";
+  /**
+   * 当传入的 `entity` 参数变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个。
+   */
+  Statuses[Statuses["InitialEntityY"] = 64] = "InitialEntityY";
+  /**
+   * 当传入的 `entity` 参数变更时，生成相关的 `key`，可作为 `hooks` 的依赖。
+   *
+   * 使用方式：
+   * * `const entityKey = statuses & Statuses.EntityKey;`
+   */
+  Statuses[Statuses["InitialEntityKey"] = 96] = "InitialEntityKey";
+  /**
+   * 当传入的 `usecase` 参数变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个。
+   */
+  Statuses[Statuses["UseCaseX"] = 128] = "UseCaseX";
+  /**
+   * 当传入的 `usecase` 参数变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个。
+   */
+  Statuses[Statuses["UseCaseY"] = 256] = "UseCaseY";
+  /**
+   * 当传入的 `usecase` 参数变更时，生成相关的 `key`，可作为 `hooks` 的依赖。
+   *
+   * 使用方式：
+   * * `const usecaseKey = statuses & Statuses.UseCaseKey;`
+   */
+  Statuses[Statuses["UseCaseKey"] = 384] = "UseCaseKey";
+  /**
+   * 当传入的 `deps` 变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个。
+   */
+  Statuses[Statuses["DepsX"] = 512] = "DepsX";
+  /**
+   * 当传入的 `deps` 变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个。
+   */
+  Statuses[Statuses["DepsY"] = 1024] = "DepsY";
+  /**
+   * 当传入的 `deps` 变更时，生成相关的 `key`，可作为 `hooks` 的依赖。
+   *
+   * 使用方式：
+   * * `const depsKey = statuses & Statuses.DepsKey;`
+   */
+  Statuses[Statuses["DepsKey"] = 1536] = "DepsKey";
+  /**
+   * 当传入的 `usecase` 或 `deps` 参数变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个；
+   * 表示将有新的 `reducers` 将会生成。
+   */
+  Statuses[Statuses["ReducersX"] = 2048] = "ReducersX";
+  /**
+   * 当传入的 `usecase` 或 `deps` 参数变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个；
+   * 表示将有新的 `reducers` 将会生成。
+   */
+  Statuses[Statuses["ReducersY"] = 4096] = "ReducersY";
+  /**
+   * 当传入的 `usecase` 或 `deps` 参数变更时，生成相关的 `key`，可作为 `hooks` 的依赖。
+   *
+   * 使用方式：
+   * * `const reducersKey = statuses & Statuses.ReducersKey;`
+   */
+  Statuses[Statuses["ReducersKey"] = 6144] = "ReducersKey";
+  /**
+   * 以下情况变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个：
+   * * 传入的 `usecase` 发生变化；
+   * * 调用 `useUseCase` 的形式发生变化；
+   * * 新增或移除根节点的 `Provider`；
+   */
+  Statuses[Statuses["RootX"] = 8192] = "RootX";
+  /**
+   * 以下情况变更时，状态会轮流切换到 `X` 或 `Y` 其中的一个：
+   * * 传入的 `usecase` 发生变化；
+   * * 调用 `useUseCase` 的形式发生变化；
+   * * 新增或移除根节点的 `Provider`；
+   */
+  Statuses[Statuses["RootY"] = 16384] = "RootY";
+  /**
+   * 根据 `root` 的变化，生成相关的 `key`，可作为 `hooks` 的依赖。
+   */
+  Statuses[Statuses["RootKey"] = 24576] = "RootKey";
 })(Statuses || (exports.Statuses = Statuses = {}));

package/lib/hooks/useAlternateStatuses/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAlternateStatuses = void 0;
+var _useChanged = require("../useChanged");
+var _useReturn = require("../useReturn");
+var _react = require("react");
+var useAlternateStatuses = exports.useAlternateStatuses = function useAlternateStatuses(value, statusesX, statusesY) {
+  var statuesRef = (0, _react.useRef)(statusesX);
+  var isChanged = (0, _useChanged.useChanged)(value);
+  return (0, _useReturn.useReturn)(function () {
+    var currentStatuses = statuesRef.current;
+    if (!isChanged) {
+      return currentStatuses;
+    }
+    var newStatuses = currentStatuses === statusesX ? statusesY : statusesX;
+    statuesRef.current = newStatuses;
+    return newStatuses;
+  });
+};

package/lib/hooks/useChanged/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useChanged = void 0;
+var _ahooks = require("ahooks");
+var useChanged = exports.useChanged = function useChanged(value) {
+  var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (newValue, oldValue) {
+    return newValue !== oldValue;
+  };
+  var prevValue = (0, _ahooks.usePrevious)(value, function () {
+    /**
+     * 这里一定要返回 `true`，不然 `value` 没有改变的话，那么 `prevValue` 也不会变，
+     * 比如：首次 `value=1`,那么 `prevValue` 的值会一直是 `undefined`，
+     * 就算组件刷新了无数次，它也是 `undefined`。
+     *
+     * 而我们期望的是：当组件第二次刷新，`prevValue` 应该是 `1`。
+     */
+    return true;
+  });
+  return callback(value, prevValue);
+};

package/lib/hooks/useContext/index.js

@@ -4,21 +4,23 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useContext = void 0;
-var _useConstant = require("../useConstant");
-var _ahooks = require("ahooks");
-var _ArgumentTypes = require("../../enums/ArgumentTypes");
-var _contextUseCase3 = require("../../usecases/contextUseCase");
-var useContext = exports.useContext = function useContext(usecase) {
-  var argumentTypes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _ArgumentTypes.ArgumentTypes.None;
-  var context = (0, _useConstant.useConstant)(function () {
-    var _contextUseCase = (0, _contextUseCase3.contextUseCase)(),
-      registerUseCase = _contextUseCase.registerUseCase;
-    return registerUseCase(usecase, argumentTypes);
-  });
-  (0, _ahooks.useUnmount)(function () {
-    var _contextUseCase2 = (0, _contextUseCase3.contextUseCase)(),
-      unregisterUseCase = _contextUseCase2.unregisterUseCase;
-    unregisterUseCase(usecase, argumentTypes);
-  });
-  return context;
+var _useConstant2 = require("../useConstant");
+var _useReturn = require("../useReturn");
+var _contextUseCase = require("../../usecases/contextUseCase");
+var useContext = exports.useContext = function useContext(usecase, isEntityRoot) {
+  var _useConstant = (0, _useConstant2.useConstant)(_contextUseCase.contextUseCase),
+    getContext = _useConstant.getContext,
+    registerUseCase = _useConstant.registerUseCase,
+    unregisterUseCase = _useConstant.unregisterUseCase;
+  return (0, _useReturn.useReturn)(function () {
+    if (isEntityRoot) {
+      return registerUseCase(usecase);
+    }
+    return getContext(usecase);
+  }, function () {
+    if (!isEntityRoot) {
+      return;
+    }
+    unregisterUseCase(usecase);
+  }, [usecase, isEntityRoot]);
 };

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

@@ -6,14 +6,13 @@ var _ = require(".");
 var _globals = require("@jest/globals");
 var _react = require("@testing-library/react");
 var _react2 = require("react");
-var _ArgumentTypes = require("../../enums/ArgumentTypes");
 var testUseCase = function testUseCase() {
   return {};
 };
 (0, _globals.describe)('useContext', function () {
-  (0, _globals.test)('should return the default context with value `null` if map has not saved a usecase with default args', function () {
+  (0, _globals.test)('should return the default context with value `null` if map has not saved a usecase without entity root mode', function () {
     var _renderHook = (0, _react.renderHook)(function () {
-        var context = (0, _.useContext)(testUseCase);
+        var context = (0, _.useContext)(testUseCase, false);
         var value = (0, _react2.useContext)(context);
         return value;
       }),
@@ -21,41 +20,31 @@ var testUseCase = function testUseCase() {
     var current = result.current;
     (0, _globals.expect)(current).toBe(null);
   });
-  (0, _globals.test)('should return the default context with value `null` if map has not saved a usecase with `ArgumentTypes.None` & `UseCaseModes.Normal`', function () {
+  (0, _globals.test)('should return the default context with value `null` after unmount this hook', function () {
     var _renderHook2 = (0, _react.renderHook)(function () {
-        var context = (0, _.useContext)(testUseCase, _ArgumentTypes.ArgumentTypes.None);
+        var context = (0, _.useContext)(testUseCase, false);
         var value = (0, _react2.useContext)(context);
         return value;
       }),
-      result = _renderHook2.result;
-    var current = result.current;
-    (0, _globals.expect)(current).toBe(null);
-  });
-  (0, _globals.test)('should return the default context with value `null` as unmount this hook', function () {
-    var _renderHook3 = (0, _react.renderHook)(function () {
-        var context = (0, _.useContext)(testUseCase, _ArgumentTypes.ArgumentTypes.None);
-        var value = (0, _react2.useContext)(context);
-        return value;
-      }),
-      result1 = _renderHook3.result,
-      unmount1 = _renderHook3.unmount;
+      result1 = _renderHook2.result,
+      unmount1 = _renderHook2.unmount;
     var current1 = result1.current;
     (0, _globals.expect)((0, _typeof2["default"])(current1)).toBe('object');
     unmount1();
-    var _renderHook4 = (0, _react.renderHook)(function () {
-        var context = (0, _.useContext)(testUseCase, _ArgumentTypes.ArgumentTypes.None);
+    var _renderHook3 = (0, _react.renderHook)(function () {
+        var context = (0, _.useContext)(testUseCase, false);
         var value = (0, _react2.useContext)(context);
         return value;
       }),
-      result2 = _renderHook4.result;
+      result2 = _renderHook3.result;
     var current2 = result2.current;
     (0, _globals.expect)(current2).toBe(null);
   });
-  (0, _globals.test)('should return a new context if map has not saved a usecase with `ArgumentTypes.Entity` & `UseCaseModes.Normal`', function () {
-    var _renderHook5 = (0, _react.renderHook)(function () {
-        return (0, _.useContext)(testUseCase, _ArgumentTypes.ArgumentTypes.Entity);
+  (0, _globals.test)('should return a new context if map has not saved a usecase with entity root mode', function () {
+    var _renderHook4 = (0, _react.renderHook)(function () {
+        return (0, _.useContext)(testUseCase, true);
       }),
-      result = _renderHook5.result;
+      result = _renderHook4.result;
     var current = result.current;
     (0, _globals.expect)((0, _typeof2["default"])(current)).toBe('object');
   });