@mic-rexjs/usecases-react 2.13.6 → 3.0.0

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

@@ -20,7 +20,7 @@ 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, TDependencies extends Dependencies = Dependencies> extends EntityInitializer<T, TDependencies> {
+export interface EntityGetter<T> extends EntityInitializer<T> {
 }
 export interface EntityWatchEvent<T, TValue = unknown> extends MatchPropertyFailedResult<T, TValue> {
 }
@@ -56,7 +56,7 @@ export interface ContextualCoreCollectionHook {
     <T, TEntityReducers extends EntityReducerMap<T>>(usecase: InferableEntityUseCase<T, TEntityReducers>, options?: UseCaseHookContextualOptions<T>, deps?: Dependencies): CoreCollection<T, TEntityReducers>;
 }
 export interface RootCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object, TDependencies extends Dependencies = Dependencies>(entity: T | EntityInitializer<T, TDependencies>, usecase: InferableEntityUseCase<T, TEntityReducers & EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: TDependencies): CoreCollection<T, EntityReducers<T, TEntityReducers>>;
+    <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>>;
 }
 export interface CoreCollectionHook extends ContextualCoreCollectionHook, RootCoreCollectionHook {
 }

package/es/index.d.ts

@@ -1,5 +1,6 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
+export type { EntityLifeCycles } from './types';
 export type { EntityWatchEvent, RootCoreCollection, ContextualCoreCollection, CoreCollection, } from './hooks/useUseCase/types';
 export type { UseCaseHookOptions } from './hooks/useUseCase/types';
 export type { UseCaseProvider } from './hooks/useProvider/types';

package/es/types.d.ts

@@ -1,7 +1,11 @@
 import { AsyncEntityCallbackGenerator, EntityGenerator, RestArguments } from '@mic-rexjs/usecases/es/types';
 export interface Dependencies extends RestArguments {
 }
-export type InitEntityResult<T> = T | EntityGenerator<T, void> | AsyncEntityCallbackGenerator<T, void>;
-export interface EntityInitializer<T, TDependencies extends Dependencies = Dependencies> {
-    (entity: T | undefined, changedDeps: Partial<TDependencies>): InitEntityResult<T>;
+export type InitEntityResult<T> = T | EntityGenerator<T> | AsyncEntityCallbackGenerator<T>;
+export interface EntityInitializer<T> {
+    (entity: T | undefined): InitEntityResult<T>;
+}
+export interface EntityLifeCycles<T> {
+    bindEntity?<S extends T>(entity: S): S | void;
+    unbindEntity?(entity: T): void;
 }

package/es/usecases/methodUseCase/index.js

@@ -2,7 +2,7 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { valueUseCase } from '../valueUseCase';
 export const methodUseCase = () => {
   const _valueUseCase = valueUseCase(),
-    isValueMatched = _valueUseCase.isValueMatched;
+    matchValue = _valueUseCase.matchValue;
   const cacheCall = (factory, options) => {
     let cache;
     const _ref = options || {},
@@ -12,7 +12,7 @@ export const methodUseCase = () => {
       } : _ref$onShouldCache,
       _ref$onCompare = _ref.onCompare,
       onCompare = _ref$onCompare === void 0 ? (newArgs, oldArgs) => {
-        return isValueMatched(newArgs, oldArgs);
+        return matchValue(newArgs, oldArgs);
       } : _ref$onCompare;
     return function () {
       const cacheable = onShouldCache();

package/es/usecases/valueUseCase/index.js

@@ -15,21 +15,21 @@ export const valueUseCase = createUseCase(() => {
     const isValueChanged = (entity, value) => {
       return entity !== value;
     };
-    const isValueMatched = (entity, value, onMatchFailed) => {
+    const matchValue = (entity, value, onMatchPropertyFailed) => {
       if (entity === value) {
         return true;
       }
       const isObject1 = typeof entity === 'object' && entity !== null;
       const isObject2 = typeof value === 'object' && value !== null;
-      if (!isObject1 || !isObject2) {
+      const keys1 = isObject1 ? Object.keys(entity) : [];
+      const keys2 = isObject2 ? Object.keys(value) : [];
+      const hasCallback = typeof onMatchPropertyFailed === 'function';
+      if (!isObject1 && !isObject2) {
         return false;
       }
       let allMatched = true;
-      const keys1 = Object.keys(entity);
-      const keys2 = Object.keys(value);
       const length1 = keys1.length;
       const keys = [...keys1, ...keys2];
-      const hasCallback = typeof onMatchFailed === 'function';
       for (let i = 0, length = keys.length; i < length; i++) {
         const key = keys[i];
         const isFromKeys2 = i >= length1;
@@ -38,20 +38,20 @@ export const valueUseCase = createUseCase(() => {
         if (isUsed) {
           continue;
         }
-        const hasField1 = Object.hasOwn(entity, key);
-        const hasField2 = Object.hasOwn(value, key);
+        const hasField1 = hasField(entity, key);
+        const hasField2 = hasField(value, key);
         const onlyHasField1 = hasField1 && !hasField2;
         const onlyHasField2 = !hasField1 && hasField2;
         const onlyHasOneField = onlyHasField1 || onlyHasField2;
-        const value1 = entity[key];
-        const value2 = value[key];
+        const value1 = hasField1 ? entity[key] : void 0;
+        const value2 = hasField2 ? value[key] : void 0;
         const matched = value1 === value2;
         if (!onlyHasOneField && matched) {
           continue;
         }
         allMatched = false;
         if (hasCallback) {
-          onMatchFailed(key, value2, value1);
+          onMatchPropertyFailed(key, value2, value1);
           continue;
         }
         break;
@@ -127,15 +127,7 @@ export const valueUseCase = createUseCase(() => {
       } 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 diffValue = (entity, value, onMatchPropertyFailed) => {
       const isArray1 = Array.isArray(entity);
       const isArray2 = Array.isArray(value);
       const isArray = isArray1 && isArray2;
@@ -145,8 +137,24 @@ export const valueUseCase = createUseCase(() => {
         const length2 = value.length;
         result.length = Math.max(length1, length2);
       }
-      const matched = isValueMatched(entity, value, (key, newValue) => {
-        result[key] = newValue;
+      matchValue(entity, value, (key, newSubValue, oldSubValue) => {
+        result[key] = newSubValue;
+        onMatchPropertyFailed === null || onMatchPropertyFailed === void 0 || onMatchPropertyFailed(key, newSubValue, oldSubValue);
+      });
+      return result;
+    };
+    const recordValue = function* (entity, value) {
+      const changed = isValueChanged(entity, value);
+      if (!changed) {
+        return false;
+      }
+      yield value;
+      return true;
+    };
+    const recordValueDiff = function* (entity, value) {
+      let matched = true;
+      const result = diffValue(entity, value, () => {
+        matched = false;
       });
       if (!matched) {
         yield value;
@@ -154,7 +162,7 @@ export const valueUseCase = createUseCase(() => {
       return result;
     };
     const recordValueMatch = function* (entity, value) {
-      const matched = isValueMatched(entity, value);
+      const matched = matchValue(entity, value);
       if (matched) {
         return true;
       }
@@ -170,8 +178,9 @@ export const valueUseCase = createUseCase(() => {
     };
     return {
       ...entityReducers,
+      diffValue,
       isValueChanged,
-      isValueMatched,
+      matchValue,
       matchProperty,
       recordValue,
       recordValueDiff,

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

@@ -4,12 +4,13 @@ import { MatchPropertyFailedResult } from '../../entities/matchPropertyFailedRes
 export interface MatchPropertyFailedCallback<T> {
     (result: MatchPropertyFailedResult<T>): void;
 }
-export interface MatchValueFailedCallback<T> {
+export interface MatchValuePropertyFailedCallback<T> {
     <K extends keyof T>(key: K, newValue: T[K], oldValue: T[K]): void;
 }
 export type ValueReducers<T> = EntityReducers<T, {
+    diffValue<S extends T>(entity: S, value: S, onMatchPropertyFailed?: MatchValuePropertyFailedCallback<S>): Partial<S>;
     isValueChanged<S extends T>(entity: S, value: S): boolean;
-    isValueMatched<S extends T>(entity: S, value: S, onMatchFailed?: MatchValueFailedCallback<S>): boolean;
+    matchValue<S extends T>(entity: S, value: S, onMatchPropertyFailed?: MatchValuePropertyFailedCallback<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>>;

package/lib/hooks/useEntity/index.js

@@ -5,26 +5,97 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useEntity = void 0;
 var _useConstantEntityReducers = require("../useConstantEntityReducers");
+var _useExec = require("../useExec");
+var _ahooks = require("ahooks");
+var _react = require("react");
 var _Statuses = require("../../enums/Statuses");
+var _triggerWatchers = require("../../methods/triggerWatchers");
 var _valueUseCase = require("../../usecases/valueUseCase");
-var useEntity = exports.useEntity = function useEntity(store, entityArg, statuses) {
+var useEntity = exports.useEntity = function useEntity(entityArg, store, reducers, statuses, options) {
+  var update = (0, _ahooks.useUpdate)();
+  var isFunction = typeof entityArg === 'function';
+  var entity = store.value;
+  var isFirstRef = (0, _react.useRef)(true);
+  var optionsRef = (0, _ahooks.useLatest)(options);
+  var prevEntityRef = (0, _react.useRef)(entity);
+  var entityEnabled = (statuses & _Statuses.Statuses.EntityEnabled) === _Statuses.Statuses.EntityEnabled;
+  var entityRootEnabled = (statuses & _Statuses.Statuses.EntityRootEnabled) === _Statuses.Statuses.EntityRootEnabled;
+  var bindEntity = reducers.bindEntity,
+    unbindEntity = reducers.unbindEntity;
   var _useConstantEntityRed = (0, _useConstantEntityReducers.useConstantEntityReducers)(entityArg, _valueUseCase.valueUseCase),
     isValueChanged = _useConstantEntityRed.isValueChanged,
     recordValue = _useConstantEntityRed.recordValue;
-  var changed = isValueChanged(entityArg);
-  var entityRootDisabled = (statuses & _Statuses.Statuses.EntityRootEnabled) !== _Statuses.Statuses.EntityRootEnabled;
-  var isFunction = typeof entityArg === 'function';
-  var value = store.value;
-  switch (true) {
-    case entityRootDisabled:
-    case isFunction:
-    case !changed:
-      return value;
-  }
-  recordValue(entityArg);
-  store.disableWatchers();
-  // 执行同步操作
-  store.setValue(entityArg);
-  store.enableWatchers();
-  return entityArg;
+  var onTriggerWatchers = (0, _ahooks.useMemoizedFn)(function (newEntity, oldEntity) {
+    var watch = optionsRef.current.watch;
+    if (!watch) {
+      return;
+    }
+    (0, _triggerWatchers.triggerWatchers)(watch, newEntity, oldEntity);
+  });
+  var onEntityChange = (0, _ahooks.useMemoizedFn)(function (newEntity, oldEntity) {
+    var onChange = optionsRef.current.onChange;
+    prevEntityRef.current = newEntity;
+    onTriggerWatchers(newEntity, oldEntity);
+    onChange === null || onChange === void 0 || onChange(newEntity, oldEntity);
+    if (!entityRootEnabled) {
+      return;
+    }
+    update();
+  });
+  var onValueChange = (0, _ahooks.useMemoizedFn)(function () {
+    if (!entityEnabled) {
+      return;
+    }
+    var prevEntity = prevEntityRef.current;
+    if (entity === prevEntity) {
+      return;
+    }
+    prevEntityRef.current = entity;
+    onTriggerWatchers(entity, prevEntity);
+  });
+  (0, _useExec.useExec)(function () {
+    var currentEntity = entityArg;
+    var isFirst = isFirstRef.current;
+    isFirstRef.current = false;
+    if (isFirst) {
+      var _bindEntity;
+      currentEntity = (_bindEntity = bindEntity === null || bindEntity === void 0 ? void 0 : bindEntity()) !== null && _bindEntity !== void 0 ? _bindEntity : currentEntity;
+    }
+    switch (true) {
+      case !entityRootEnabled:
+      case isFunction:
+      case !isValueChanged(currentEntity):
+        return;
+    }
+    recordValue(currentEntity);
+    store.disableWatchers();
+    // 执行同步操作
+    store.setValue(currentEntity);
+    store.enableWatchers();
+  });
+  /**
+   * 需要马上 `watch`，因为 `useEffect` 在子组件内优先执行，
+   * 如果使用了 `setEntity` 则无法监控到变化
+   */
+  (0, _useExec.useExec)(function () {
+    if (!entityEnabled) {
+      return;
+    }
+    store.watch(onEntityChange);
+  }, [entityEnabled, store, onEntityChange]);
+  /**
+   * 在变化时候，组件更新前，使用 `unwatch`
+   */
+  (0, _react.useEffect)(function () {
+    return function () {
+      store.unwatch(onEntityChange);
+    };
+  }, [entityEnabled, store, onEntityChange]);
+  (0, _ahooks.useUnmount)(function () {
+    unbindEntity === null || unbindEntity === void 0 || unbindEntity();
+  });
+  (0, _ahooks.useUpdateEffect)(function () {
+    onValueChange();
+  }, [entity, onValueChange]);
+  return store.value;
 };

package/lib/hooks/useExec/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 depsKey = (0, _useDepsKey.useDepsKey)(deps);
+  var execCallback = (0, _ahooks.useMemoizedFn)(function () {
+    callback();
+  });
+  (0, _ahooks.useCreation)(function () {
+    void depsKey;
+    execCallback();
+  }, [depsKey, execCallback]);
+};

package/lib/hooks/useReducers/index.js

@@ -27,7 +27,7 @@ var useReducers = exports.useReducers = function useReducers(usecase, context, s
     contextReducers = _ref$reducers === void 0 ? null : _ref$reducers;
   var _useConstantReducers = (0, _useConstantReducers2.useConstantReducers)(_methodUseCase.methodUseCase),
     captureCalls = _useConstantReducers.captureCalls;
-  return (0, _useContextualItem.useContextualItem)(contextReducers, statuses, function () {
+  var reducers = (0, _useContextualItem.useContextualItem)(contextReducers, statuses, function () {
     var opts = captureCalls(options, function (key, callArgs) {
       var _optionsRef$current$k2;
       var _optionsRef$current$k, _optionsRef$current;
@@ -47,4 +47,5 @@ var useReducers = exports.useReducers = function useReducers(usecase, context, s
       }
     }));
   }, deps);
+  return reducers;
 };

package/lib/hooks/useStore/index.js

@@ -1,95 +1,72 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useStore = void 0;
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _useConstantEntityReducers = require("../useConstantEntityReducers");
 var _useContextualItem = require("../useContextualItem");
 var _usecases = require("@mic-rexjs/usecases");
-var _ahooks = require("ahooks");
 var _react = require("react");
 var _Statuses = require("../../enums/Statuses");
-var _initStore = require("../../methods/initStore");
-var _triggerWatchers = require("../../methods/triggerWatchers");
-var _valueUseCase = require("../../usecases/valueUseCase");
-var useStore = exports.useStore = function useStore(context, entity, statuses, options) {
+var _entityRuntimeUseCase = require("../../usecases/entityRuntimeUseCase");
+var _valueUseCase2 = require("../../usecases/valueUseCase");
+var useStore = exports.useStore = function useStore(entityArg, context, statuses, options) {
   var deps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
-  var update = (0, _ahooks.useUpdate)();
-  var optionsRef = (0, _ahooks.useLatest)(options);
   var storeRef = (0, _react.useRef)(null);
-  var entityEnabled = (statuses & _Statuses.Statuses.EntityEnabled) === _Statuses.Statuses.EntityEnabled;
+  var createEntityListRef = (0, _react.useRef)([]);
   var entityRootEnabled = (statuses & _Statuses.Statuses.EntityRootEnabled) === _Statuses.Statuses.EntityRootEnabled;
   var contextValue = (0, _react.useContext)(context);
   var _ref = contextValue || {},
     _ref$store = _ref.store,
     contextStore = _ref$store === void 0 ? null : _ref$store;
-  var _useConstantEntityRed = (0, _useConstantEntityReducers.useConstantEntityReducers)([], _valueUseCase.valueUseCase),
-    recordValueDiff = _useConstantEntityRed.recordValueDiff;
-  var store = (0, _useContextualItem.useContextualItem)(contextStore, statuses, function () {
+  var initStore = function initStore() {
+    var isFunction = typeof entityArg === 'function';
+    if (!isFunction) {
+      return new _usecases.EntityStore(entityArg);
+    }
+    var index = 0;
+    var currentStore = storeRef.current;
+    var _ref2 = currentStore || {},
+      currentEntity = _ref2.value;
+    var prevCreateEntityList = createEntityListRef.current;
+    var store = new _usecases.EntityStore(currentEntity);
+    var createEntityList = [];
+    var _valueUseCase = (0, _valueUseCase2.valueUseCase)(),
+      diffValue = _valueUseCase.diffValue;
+    var _createEntityReducers = (0, _usecases.createEntityReducers)(store, _entityRuntimeUseCase.entityRuntimeUseCase, {
+        onInit: function onInit(currentValue) {
+          return entityArg(currentValue);
+        },
+        onCreate: function onCreate(newEntity, oldEntity) {
+          var prevEntity = prevCreateEntityList[index];
+          var diffEntity = diffValue(prevEntity, newEntity);
+          createEntityList[index] = newEntity;
+          index++;
+          return (0, _usecases.createEntity)(oldEntity, diffEntity);
+        },
+        onGenerate: function onGenerate(entity, result) {
+          if (typeof result === 'undefined') {
+            return [entity, result];
+          }
+          var newResult = (0, _usecases.createEntity)(entity, result);
+          store.value = newResult;
+          return [newResult, result];
+        },
+        onReturn: function onReturn(result) {
+          store.value = result;
+          return result;
+        }
+      }),
+      initEntity = _createEntityReducers.initEntity;
+    initEntity();
+    storeRef.current = store;
+    createEntityListRef.current = createEntityList;
+    return store;
+  };
+  return (0, _useContextualItem.useContextualItem)(contextStore, statuses, function () {
     if (!entityRootEnabled) {
       return new _usecases.EntityStore(null);
     }
-    var current = storeRef.current;
-    var _recordValueDiff = recordValueDiff(deps),
-      _recordValueDiff2 = (0, _slicedToArray2["default"])(_recordValueDiff, 2),
-      changedDeps = _recordValueDiff2[1];
-    var newStore = (0, _initStore.initStore)(entity, current, changedDeps);
-    storeRef.current = newStore;
-    return newStore;
+    return initStore();
   }, deps);
-  var value = store.value;
-  var prevValueRef = (0, _react.useRef)(value);
-  var onTriggerWatchers = (0, _ahooks.useMemoizedFn)(function (newEntity, oldEntity) {
-    var watch = optionsRef.current.watch;
-    if (!watch) {
-      return;
-    }
-    (0, _triggerWatchers.triggerWatchers)(watch, newEntity, oldEntity);
-  });
-  var onEntityChange = (0, _ahooks.useMemoizedFn)(function (newEntity, oldEntity) {
-    var onChange = optionsRef.current.onChange;
-    prevValueRef.current = newEntity;
-    onTriggerWatchers(newEntity, oldEntity);
-    onChange === null || onChange === void 0 || onChange(newEntity, oldEntity);
-    if (!entityRootEnabled) {
-      return;
-    }
-    update();
-  });
-  var onValueChange = (0, _ahooks.useMemoizedFn)(function () {
-    if (!entityEnabled) {
-      return;
-    }
-    var prevValue = prevValueRef.current;
-    if (value === prevValue) {
-      return;
-    }
-    prevValueRef.current = value;
-    onTriggerWatchers(value, prevValue);
-  });
-  /**
-   * 需要马上 `watch`，因为 `useEffect` 在子组件内优先执行，
-   * 如果使用了 `setEntity` 则无法监控到变化
-   */
-  (0, _ahooks.useCreation)(function () {
-    if (!entityEnabled) {
-      return;
-    }
-    store.watch(onEntityChange);
-  }, [entityEnabled, store, onEntityChange]);
-  /**
-   * 在变化时候，组件更新前，使用 `unwatch`
-   */
-  (0, _react.useEffect)(function () {
-    return function () {
-      store.unwatch(onEntityChange);
-    };
-  }, [entityEnabled, store, onEntityChange]);
-  (0, _ahooks.useUpdateEffect)(function () {
-    onValueChange();
-  }, [value, onValueChange]);
-  return store;
 };

package/lib/hooks/useUseCase/index.js

@@ -42,9 +42,9 @@ var useUseCase = exports.useUseCase = function useUseCase() {
   var context = (0, _useContext.useContext)(usecase, argumentTypes);
   var entityContext = context;
   var statuses = (0, _useStatuses.useStatuses)(context, argumentTypes);
-  var store = (0, _useStore.useStore)(entityContext, unsafeEntity, statuses, options, deps);
-  var entity = (0, _useEntity.useEntity)(store, unsafeEntity, statuses);
+  var store = (0, _useStore.useStore)(unsafeEntity, entityContext, statuses, options, deps);
   var reducers = (0, _useReducers.useReducers)(usecase, context, store, statuses, options, deps);
+  var entity = (0, _useEntity.useEntity)(unsafeEntity, store, reducers, statuses, options);
   var Provider = (0, _useProvider.useProvider)(statuses, context, store, reducers);
   return (0, _ahooks.useCreation)(function () {
     if ((statuses & _Statuses.Statuses.EntityEnabled) !== _Statuses.Statuses.EntityEnabled) {