@mic-rexjs/usecases-react 2.14.0 → 3.0.1

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

@@ -1,38 +1,74 @@
 "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 _react = require("react");
 var _Statuses = require("../../enums/Statuses");
-var _initStore = require("../../methods/initStore");
-var _valueUseCase = require("../../usecases/valueUseCase");
+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 storeRef = (0, _react.useRef)(null);
+  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 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`，因为可能存在异步，异步更新是需要触发组件更新的
+          store.setValue(newResult);
+          return [newResult, result];
+        },
+        onReturn: function onReturn(result) {
+          // 不能用 `store.value`，因为可能存在异步，异步更新是需要触发组件更新的
+          store.setValue(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)(entityArg, current, changedDeps);
-    storeRef.current = newStore;
-    return newStore;
+    return initStore();
   }, deps);
 };