@mic-rexjs/usecases-react 2.12.0 → 2.12.1

package/es/hooks/useUseCase/types.js

@@ -1 +1 @@
-export {};
+export {};

package/es/index.js

@@ -1,2 +1,2 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
-export { useUseCase } from './hooks/useUseCase';
+export { useUseCase } from './hooks/useUseCase';

package/es/methods/triggerWatchers/index.js

@@ -1,9 +1,14 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { valueUseCase } from '../../usecases/valueUseCase';
 export const triggerWatchers = (watch, newEntity, oldEntity) => {
-    const { matchProperty } = valueUseCase();
-    for (const [fieldPath, watcher] of Object.entries(watch)) {
-        matchProperty(oldEntity, newEntity, fieldPath, (result) => {
-            watcher(result);
-        });
-    }
-};
+  const _valueUseCase = valueUseCase(),
+    matchProperty = _valueUseCase.matchProperty;
+  for (const _ref of Object.entries(watch)) {
+    var _ref2 = _slicedToArray(_ref, 2);
+    const fieldPath = _ref2[0];
+    const watcher = _ref2[1];
+    matchProperty(oldEntity, newEntity, fieldPath, result => {
+      watcher(result);
+    });
+  }
+};

package/es/types.js

@@ -1 +1 @@
-export {};
+export {};

package/es/usecases/contextUseCase/index.js

@@ -3,71 +3,76 @@ 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 getUseCaseContext = (usecase) => {
-            if (!referenceMap.has(usecase)) {
-                return defaultUseCaseContext;
-            }
-            const { value } = referenceMap.get(usecase);
-            return value;
-        };
-        const registerUseCase = (usecase, argumentTypes) => {
-            if (referenceMap.has(usecase)) {
-                const reference = referenceMap.get(usecase);
-                const { value, times } = reference;
-                referenceMap.set(usecase, {
-                    value,
-                    times: times + 1,
-                });
-                return value;
-            }
-            if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
-                return defaultUseCaseContext;
-            }
-            const context = createContext(null);
-            referenceMap.set(usecase, {
-                value: context,
-                times: 1,
-            });
-            return context;
-        };
-        const unregisterUseCase = (usecase, argumentTypes) => {
-            if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
-                return false;
-            }
-            if (!referenceMap.has(usecase)) {
-                return false;
-            }
-            const reference = referenceMap.get(usecase);
-            const { value, times } = reference;
-            if (times === 1) {
-                referenceMap.delete(usecase);
-            }
-            else {
-                referenceMap.set(usecase, {
-                    value,
-                    times: times - 1,
-                });
-            }
-            return true;
-        };
+  const referenceMap = new Map();
+  const defaultUseCaseContext = createContext(null);
+  return () => {
+    const createContextValue = (store, reducers, statuses) => {
+      if ((statuses & Statuses.EntityEnabled) === Statuses.EntityEnabled) {
         return {
-            createContextValue,
-            getUseCaseContext,
-            registerUseCase,
-            unregisterUseCase,
+          store,
+          reducers,
+          statuses
         };
+      }
+      return {
+        reducers,
+        statuses
+      };
+    };
+    const getUseCaseContext = usecase => {
+      if (!referenceMap.has(usecase)) {
+        return defaultUseCaseContext;
+      }
+      const _referenceMap$get = referenceMap.get(usecase),
+        value = _referenceMap$get.value;
+      return value;
+    };
+    const registerUseCase = (usecase, argumentTypes) => {
+      if (referenceMap.has(usecase)) {
+        const reference = referenceMap.get(usecase);
+        const value = reference.value,
+          times = reference.times;
+        referenceMap.set(usecase, {
+          value,
+          times: times + 1
+        });
+        return value;
+      }
+      if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
+        return defaultUseCaseContext;
+      }
+      const context = createContext(null);
+      referenceMap.set(usecase, {
+        value: context,
+        times: 1
+      });
+      return context;
+    };
+    const unregisterUseCase = (usecase, argumentTypes) => {
+      if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
+        return false;
+      }
+      if (!referenceMap.has(usecase)) {
+        return false;
+      }
+      const reference = referenceMap.get(usecase);
+      const value = reference.value,
+        times = reference.times;
+      if (times === 1) {
+        referenceMap.delete(usecase);
+      } else {
+        referenceMap.set(usecase, {
+          value,
+          times: times - 1
+        });
+      }
+      return true;
+    };
+    return {
+      createContextValue,
+      getUseCaseContext,
+      registerUseCase,
+      unregisterUseCase
     };
-});
+  };
+});

package/es/usecases/contextUseCase/types.js

@@ -1 +1 @@
-export {};
+export {};

package/es/usecases/methodUseCase/index.js

@@ -1,55 +1,72 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 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 _valueUseCase = valueUseCase(),
+    isValueMatched = _valueUseCase.isValueMatched;
+  const cacheCall = (factory, options) => {
+    let cache;
+    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 isValueMatched(newArgs, oldArgs);
+      } : _ref$onCompare;
+    return function () {
+      const cacheable = onShouldCache();
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (cache && cacheable) {
+        const _cache = cache,
+          parameters = _cache.parameters,
+          returnValue = _cache.returnValue;
+        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,
-    };
-};
+  };
+  const cacheCalls = (sourceFactories, options) => {
+    const cachedFactories = {};
+    Object.entries(sourceFactories).forEach(_ref2 => {
+      let _ref3 = _slicedToArray(_ref2, 2),
+        key = _ref3[0],
+        factory = _ref3[1];
+      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] = function () {
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          return callback(key, args);
+        };
+        return;
+      }
+      newObj[key] = value;
+    });
+    return newObj;
+  };
+  return {
+    cacheCall,
+    cacheCalls,
+    captureCalls
+  };
+};

package/es/usecases/methodUseCase/types.js

@@ -1 +1 @@
-export {};
+export {};

package/es/usecases/valueUseCase/index.js

@@ -1,170 +1,178 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { createUseCase, entityUseCase, utilsUseCase } from '@mic-rexjs/usecases';
 export const valueUseCase = createUseCase(() => {
-    return () => {
-        const { createKey } = utilsUseCase();
-        let prevKeyIndex = createKey();
-        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) {
-            const matched = yield* recordValueMatch(entity, value);
-            if (!matched) {
-                prevKeyIndex = key ?? createKey();
-            }
-            return prevKeyIndex;
-        };
-        return {
-            ...entityReducers,
-            isValueChanged,
-            isValueMatched,
-            matchProperty,
-            recordValue,
-            recordValueDiff,
-            recordValueMatch,
-            recordValueMatchWith,
-        };
+  return () => {
+    const _utilsUseCase = utilsUseCase(),
+      createKey = _utilsUseCase.createKey;
+    let prevKeyIndex = createKey();
+    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 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;
+        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 _list$shift = list.shift(),
+          oldValue = _list$shift.oldValue,
+          newValue = _list$shift.newValue,
+          fieldPaths = _list$shift.fieldPaths;
+        const _ref = currentFieldPath.match(/^([^.]+)\.(.+)$/) || [],
+          _ref2 = _slicedToArray(_ref, 3),
+          _ref2$ = _ref2[1],
+          key = _ref2$ === void 0 ? currentFieldPath : _ref2$,
+          _ref2$2 = _ref2[2],
+          subFieldPath = _ref2$2 === void 0 ? '' : _ref2$2;
+        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 === null || onFailed === void 0 || onFailed(result);
+          continue;
+        }
+        if (/^\d+^/.test(key)) {
+          continue;
+        }
+        const oldArray = Array.isArray(oldValue) ? oldValue : [];
+        const newArray = Array.isArray(newValue) ? newValue : [];
+        const oldLength = oldArray.length;
+        const newLength = newArray.length;
+        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 length1 = entity.length;
+        const length2 = value.length;
+        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) {
+      const matched = yield* recordValueMatch(entity, value);
+      if (!matched) {
+        prevKeyIndex = key !== null && key !== void 0 ? key : createKey();
+      }
+      return prevKeyIndex;
+    };
+    return {
+      ...entityReducers,
+      isValueChanged,
+      isValueMatched,
+      matchProperty,
+      recordValue,
+      recordValueDiff,
+      recordValueMatch,
+      recordValueMatchWith
+    };
+  };
+});

package/es/usecases/valueUseCase/types.js

@@ -1 +1 @@
-export {};
+export {};

package/lib/components/UseCaseFragment/index.js

@@ -12,9 +12,9 @@ var _useUseCase2 = require("../../hooks/useUseCase");
 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; }
+var _excluded = ["usecase"];
 var UseCaseFragment = exports.UseCaseFragment = function UseCaseFragment(_ref) {
   var usecase = _ref.usecase,
     props = (0, _objectWithoutProperties2["default"])(_ref, _excluded);