@mic-rexjs/usecases-react 3.1.0 → 3.1.2

package/es/usecases/valueUseCase/index.js

@@ -6,11 +6,18 @@ export const valueUseCase = createUseCase(() => {
     const _utilsUseCase = utilsUseCase(),
       createKey = _utilsUseCase.createKey;
     let prevKeyIndex = createKey();
-    const hasField = (entity, field) => {
+    const isObjectValue = entity => {
       if (typeof entity !== 'object' || entity === null) {
         return false;
       }
-      return Object.hasOwn(entity, field);
+      return true;
+    };
+    const hasField = (entity, field) => {
+      const isObject = isObjectValue(entity);
+      if (isObject) {
+        return Object.hasOwn(entity, field);
+      }
+      return false;
     };
     const isValueChanged = (entity, value) => {
       return entity !== value;
@@ -19,8 +26,8 @@ export const valueUseCase = createUseCase(() => {
       if (entity === value) {
         return true;
       }
-      const isObject1 = typeof entity === 'object' && entity !== null;
-      const isObject2 = typeof value === 'object' && value !== null;
+      const isObject1 = isObjectValue(entity);
+      const isObject2 = isObjectValue(value);
       const keys1 = isObject1 ? Object.keys(entity) : [];
       const keys2 = isObject2 ? Object.keys(value) : [];
       const hasCallback = typeof onMatchPropertyFailed === 'function';
@@ -32,21 +39,18 @@ export const valueUseCase = createUseCase(() => {
       const keys = [...keys1, ...keys2];
       for (let i = 0, length = keys.length; i < length; i++) {
         const key = keys[i];
-        const isFromKeys2 = i >= length1;
         const isInKey1 = keys1.includes(key);
+        const isFromKeys2 = i >= length1;
         const isUsed = isFromKeys2 && isInKey1;
         if (isUsed) {
           continue;
         }
         const hasField1 = hasField(entity, key);
         const hasField2 = hasField(value, key);
-        const onlyHasField1 = hasField1 && !hasField2;
-        const onlyHasField2 = !hasField1 && hasField2;
-        const onlyHasOneField = onlyHasField1 || onlyHasField2;
         const value1 = hasField1 ? entity[key] : void 0;
         const value2 = hasField2 ? value[key] : void 0;
         const matched = value1 === value2;
-        if (!onlyHasOneField && matched) {
+        if (hasField1 && hasField2 && matched) {
           continue;
         }
         allMatched = false;
@@ -127,22 +131,6 @@ export const valueUseCase = createUseCase(() => {
       } while (list.length > 0);
       return allMatched;
     };
-    const diffValue = (entity, value, onMatchPropertyFailed) => {
-      const isArray1 = Array.isArray(entity);
-      const isArray2 = Array.isArray(value);
-      const isArray = isArray1 && isArray2;
-      const result = isArray ? [] : {};
-      if (isArray) {
-        const length1 = entity.length;
-        const length2 = value.length;
-        result.length = Math.max(length1, length2);
-      }
-      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) {
@@ -151,16 +139,6 @@ export const valueUseCase = createUseCase(() => {
       yield value;
       return true;
     };
-    const recordValueDiff = function* (entity, value) {
-      let matched = true;
-      const result = diffValue(entity, value, () => {
-        matched = false;
-      });
-      if (!matched) {
-        yield value;
-      }
-      return result;
-    };
     const recordValueMatch = function* (entity, value) {
       const matched = matchValue(entity, value);
       if (matched) {
@@ -178,12 +156,11 @@ export const valueUseCase = createUseCase(() => {
     };
     return {
       ...entityReducers,
-      diffValue,
+      isObjectValue,
       isValueChanged,
       matchValue,
       matchProperty,
       recordValue,
-      recordValueDiff,
       recordValueMatch,
       recordValueMatchWith
     };

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

@@ -8,12 +8,11 @@ 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>;
+    isObjectValue(entity: T): boolean;
     isValueChanged<S extends T>(entity: S, value: 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>>;
     recordValueMatch<S extends T>(entity: S, value: S): EntityGenerator<S, boolean>;
     recordValueMatchWith<S extends T>(entity: S, value: S, key?: React.Key): EntityGenerator<S, React.Key>;
 }>;

package/lib/hooks/useStore/index.js

@@ -32,17 +32,31 @@ var useStore = exports.useStore = function useStore(entityArg, context, statuses
     var store = new _usecases.EntityStore(currentEntity);
     var createEntityList = [];
     var _valueUseCase = (0, _valueUseCase2.valueUseCase)(),
-      diffValue = _valueUseCase.diffValue;
+      isObjectValue = _valueUseCase.isObjectValue,
+      matchValue = _valueUseCase.matchValue;
     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;
+          var currentIndex = index;
+          var isObject = isObjectValue(oldEntity);
+          var isArray = isObject && Array.isArray(oldEntity);
           index++;
-          return (0, _usecases.createEntity)(oldEntity, diffEntity);
+          createEntityList[currentIndex] = newEntity;
+          if (!isObject || isArray) {
+            return (0, _usecases.createEntity)(oldEntity, newEntity);
+          }
+          var descriptors = {};
+          var prevEntity = prevCreateEntityList[currentIndex];
+          matchValue(prevEntity, newEntity, function (key) {
+            var descriptor = Object.getOwnPropertyDescriptor(newEntity, key) || null;
+            if (descriptor === null) {
+              return;
+            }
+            descriptors[key] = descriptor;
+          });
+          return (0, _usecases.createEntity)(oldEntity, Object.defineProperties({}, descriptors));
         },
         onGenerate: function onGenerate(entity, result) {
           if (typeof result === 'undefined') {