@mic-rexjs/usecases-react 2.10.2 → 2.11.0

package/lib/methods/triggerWatchers/index.js

@@ -6,20 +6,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.triggerWatchers = void 0;
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _compareProperty = require("../compareProperty");
+var _valueUseCase2 = require("../../usecases/valueUseCase");
 var triggerWatchers = exports.triggerWatchers = function triggerWatchers(watch, newEntity, oldEntity) {
+  var _valueUseCase = (0, _valueUseCase2.valueUseCase)(),
+    matchProperty = _valueUseCase.matchProperty;
   var _loop = function _loop() {
     var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
       fieldPath = _Object$entries$_i[0],
       watcher = _Object$entries$_i[1];
-    (0, _compareProperty.compareProperty)(oldEntity, newEntity, fieldPath, function (oldValue, newValue, fieldPaths) {
-      watcher({
-        fieldPaths: fieldPaths,
-        newEntity: newEntity,
-        oldEntity: oldEntity,
-        newValue: newValue,
-        oldValue: oldValue
-      });
+    matchProperty(oldEntity, newEntity, fieldPath, function (result) {
+      watcher(result);
     });
   };
   for (var _i = 0, _Object$entries = Object.entries(watch); _i < _Object$entries.length; _i++) {

package/lib/usecases/contextUseCase/index.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.contextUseCase = void 0;
 var _usecases = require("@mic-rexjs/usecases");
-var _ArgumentTypes = require("../../enums/ArgumentTypes");
 var _react = require("react");
+var _ArgumentTypes = require("../../enums/ArgumentTypes");
 var _Statuses = require("../../enums/Statuses");
 var contextUseCase = exports.contextUseCase = (0, _usecases.createUseCase)(function () {
   var referenceMap = new Map();

package/lib/usecases/methodUseCase/index.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.methodUseCase = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _valueUseCase2 = require("../valueUseCase");
+var methodUseCase = exports.methodUseCase = function methodUseCase() {
+  var _valueUseCase = (0, _valueUseCase2.valueUseCase)(),
+    isValueMatched = _valueUseCase.isValueMatched;
+  var cacheCall = function cacheCall(factory, options) {
+    var cache;
+    var _ref = options || {},
+      _ref$onShouldCache = _ref.onShouldCache,
+      onShouldCache = _ref$onShouldCache === void 0 ? function () {
+        return true;
+      } : _ref$onShouldCache,
+      _ref$onCompare = _ref.onCompare,
+      onCompare = _ref$onCompare === void 0 ? function (newArgs, oldArgs) {
+        return isValueMatched(newArgs, oldArgs);
+      } : _ref$onCompare;
+    return function () {
+      var cacheable = onShouldCache();
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (cache && cacheable) {
+        var _cache = cache,
+          parameters = _cache.parameters,
+          _returnValue = _cache.returnValue;
+        if (onCompare(parameters, args)) {
+          return _returnValue;
+        }
+      }
+      var returnValue = factory.apply(void 0, args);
+      if (cacheable) {
+        cache = {
+          parameters: args,
+          returnValue: returnValue
+        };
+      }
+      return returnValue;
+    };
+  };
+  var cacheCalls = function cacheCalls(sourceFactories, options) {
+    var cachedFactories = {};
+    Object.entries(sourceFactories).forEach(function (_ref2) {
+      var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
+        key = _ref3[0],
+        factory = _ref3[1];
+      cachedFactories[key] = cacheCall(factory, options);
+    });
+    return cachedFactories;
+  };
+  var captureCalls = function captureCalls(obj, callback) {
+    var newObj = {};
+    Object.keys(obj).forEach(function (key) {
+      var 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: cacheCall,
+    cacheCalls: cacheCalls,
+    captureCalls: captureCalls
+  };
+};

package/lib/usecases/valueUseCase/index.js

@@ -0,0 +1,246 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.valueUseCase = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _usecases = require("@mic-rexjs/usecases");
+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 valueUseCase = exports.valueUseCase = (0, _usecases.createUseCase)(function () {
+  var keyIndex = 0;
+  return function () {
+    var prevKeyIndex = keyIndex++;
+    var entityReducers = (0, _usecases.entityUseCase)();
+    var hasField = function hasField(entity, field) {
+      if ((0, _typeof2["default"])(entity) !== 'object' || entity === null) {
+        return false;
+      }
+      return Object.hasOwn(entity, field);
+    };
+    var isValueChanged = function isValueChanged(entity, value) {
+      return entity !== value;
+    };
+    var isValueMatched = function isValueMatched(entity, value, onMatchFailed) {
+      if (entity === value) {
+        return true;
+      }
+      var isObject1 = (0, _typeof2["default"])(entity) === 'object' && entity !== null;
+      var isObject2 = (0, _typeof2["default"])(value) === 'object' && value !== null;
+      if (!isObject1 || !isObject2) {
+        return false;
+      }
+      var allMatched = true;
+      var keys1 = Object.keys(entity);
+      var keys2 = Object.keys(value);
+      var length1 = keys1.length;
+      var keys = [].concat(keys1, keys2);
+      var hasCallback = typeof onMatchFailed === 'function';
+      for (var i = 0, length = keys.length; i < length; i++) {
+        var key = keys[i];
+        var isFromKeys2 = i >= length1;
+        var isInKey1 = keys1.includes(key);
+        var isUsed = isFromKeys2 && isInKey1;
+        if (isUsed) {
+          continue;
+        }
+        var hasField1 = Object.hasOwn(entity, key);
+        var hasField2 = Object.hasOwn(value, key);
+        var onlyHasField1 = hasField1 && !hasField2;
+        var onlyHasField2 = !hasField1 && hasField2;
+        var onlyHasOneField = onlyHasField1 || onlyHasField2;
+        var value1 = entity[key];
+        var value2 = value[key];
+        var matched = value1 === value2;
+        if (!onlyHasOneField && matched) {
+          continue;
+        }
+        allMatched = false;
+        if (hasCallback) {
+          onMatchFailed(key, value2, value1);
+          continue;
+        }
+        break;
+      }
+      return allMatched;
+    };
+    var matchProperty = function matchProperty(entity, value, fieldPath, onFailed) {
+      var allMatched = true;
+      var currentFieldPath = fieldPath;
+      var list = [{
+        fieldPaths: [],
+        newEntity: value,
+        newValue: value,
+        oldEntity: entity,
+        oldValue: entity
+      }];
+      do {
+        var _list$shift = list.shift(),
+          oldValue = _list$shift.oldValue,
+          newValue = _list$shift.newValue,
+          fieldPaths = _list$shift.fieldPaths;
+        var _ref = currentFieldPath.match(/^([^.]+)\.(.+)$/) || [],
+          _ref2 = (0, _slicedToArray2["default"])(_ref, 3),
+          _ref2$ = _ref2[1],
+          key = _ref2$ === void 0 ? currentFieldPath : _ref2$,
+          _ref2$2 = _ref2[2],
+          subFieldPath = _ref2$2 === void 0 ? '' : _ref2$2;
+        var hasOldField = hasField(oldValue, key);
+        var hasNewField = hasField(newValue, key);
+        if (hasOldField || hasNewField) {
+          var subOldValue = hasOldField ? oldValue[key] : void 0;
+          var subNewValue = hasNewField ? newValue[key] : void 0;
+          var result = {
+            fieldPaths: [].concat((0, _toConsumableArray2["default"])(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;
+        }
+        var oldArray = Array.isArray(oldValue) ? oldValue : [];
+        var newArray = Array.isArray(newValue) ? newValue : [];
+        var oldLength = oldArray.length;
+        var newLength = newArray.length;
+        var length = Math.max(oldLength, newLength);
+        for (var i = 0; i < length; i++) {
+          list.push({
+            fieldPaths: [].concat((0, _toConsumableArray2["default"])(fieldPaths), ["".concat(i)]),
+            newEntity: value,
+            newValue: newArray[i],
+            oldEntity: entity,
+            oldValue: oldArray[i]
+          });
+        }
+      } while (list.length > 0);
+      return allMatched;
+    };
+    var recordValue = /*#__PURE__*/_regenerator["default"].mark(function recordValue(entity, value) {
+      var changed;
+      return _regenerator["default"].wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            changed = isValueChanged(entity, value);
+            if (changed) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return", false);
+          case 1:
+            _context.next = 2;
+            return value;
+          case 2:
+            return _context.abrupt("return", true);
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }, recordValue);
+    });
+    var recordValueDiff = /*#__PURE__*/_regenerator["default"].mark(function recordValueDiff(entity, value) {
+      var isArray1, isArray2, isArray, result, length1, length2, matched;
+      return _regenerator["default"].wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            isArray1 = Array.isArray(entity);
+            isArray2 = Array.isArray(value);
+            isArray = isArray1 && isArray2;
+            result = isArray ? [] : {};
+            if (isArray) {
+              length1 = entity.length;
+              length2 = value.length;
+              result.length = Math.max(length1, length2);
+            }
+            matched = isValueMatched(entity, value, function (key, newValue) {
+              result[key] = newValue;
+            });
+            if (matched) {
+              _context2.next = 1;
+              break;
+            }
+            _context2.next = 1;
+            return value;
+          case 1:
+            return _context2.abrupt("return", result);
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, recordValueDiff);
+    });
+    var recordValueMatch = /*#__PURE__*/_regenerator["default"].mark(function recordValueMatch(entity, value) {
+      var matched;
+      return _regenerator["default"].wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            matched = isValueMatched(entity, value);
+            if (!matched) {
+              _context3.next = 1;
+              break;
+            }
+            return _context3.abrupt("return", true);
+          case 1:
+            _context3.next = 2;
+            return value;
+          case 2:
+            return _context3.abrupt("return", false);
+          case 3:
+          case "end":
+            return _context3.stop();
+        }
+      }, recordValueMatch);
+    });
+    var recordValueMatchWith = function recordValueMatchWith(entity, value) {
+      var key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : keyIndex + 1;
+      return /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var matched;
+        return _regenerator["default"].wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.delegateYield(recordValueMatch(entity, value), "t0", 1);
+            case 1:
+              matched = _context4.t0;
+              if (!matched) {
+                // 不管是不是使用 `keyIndex` 生成的 `key`，都自增一次，如果是，则可以保持一致
+                keyIndex++;
+                prevKeyIndex = key;
+              }
+              return _context4.abrupt("return", prevKeyIndex);
+            case 2:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee);
+      })();
+    };
+    return _objectSpread(_objectSpread({}, entityReducers), {}, {
+      isValueChanged: isValueChanged,
+      isValueMatched: isValueMatched,
+      matchProperty: matchProperty,
+      recordValue: recordValue,
+      recordValueDiff: recordValueDiff,
+      recordValueMatch: recordValueMatch,
+      recordValueMatchWith: recordValueMatchWith
+    });
+  };
+});

package/lib/usecases/valueUseCase/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mic-rexjs/usecases-react",
-  "version": "2.10.2",
+  "version": "2.11.0",
   "description": "React-based solution for use usecases of Clean Architecture",
   "private": false,
   "sideEffects": false,
@@ -35,50 +35,55 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@mic-rexjs/usecases": "^2.13.0",
-    "react": "^16.8.0 || ^17.0.0 || ^18.0.0"
+    "@mic-rexjs/usecases": "^2.14.2",
+    "react": ">=16.8.0"
   },
   "dependencies": {
-    "@babel/plugin-transform-runtime": "^7.22.7",
-    "@babel/preset-env": "^7.22.7",
-    "ahooks": "^3.7.8"
+    "@babel/plugin-transform-runtime": "^7.29.0",
+    "@babel/preset-env": "^7.29.5",
+    "ahooks": "^3.9.7"
   },
   "devDependencies": {
-    "@babel/cli": "^7.22.9",
-    "@babel/core": "^7.22.8",
-    "@babel/preset-react": "^7.22.5",
-    "@babel/preset-typescript": "^7.22.5",
-    "@commitlint/cli": "^19.0.3",
-    "@commitlint/config-angular": "^19.0.3",
-    "@jest/globals": "^29.5.0",
-    "@mic-rexjs/usecases": "^2.13.0",
-    "@testing-library/react": "^14.0.0",
-    "@types/node": "^20.4.2",
-    "@types/react": "^18.2.14",
-    "@types/react-dom": "^18.2.7",
-    "@typescript-eslint/eslint-plugin": "^7.1.1",
-    "@typescript-eslint/parser": "^7.1.1",
-    "babel-loader": "^9.1.3",
-    "copy-webpack-plugin": "^12.0.2",
-    "eslint": "^8.42.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-jest": "^27.2.1",
-    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "husky": "^9.0.11",
-    "jest": "^29.5.0",
-    "jest-environment-jsdom": "^29.6.1",
-    "lint-staged": "^15.2.2",
-    "prettier": "^3.2.5",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "rimraf": "^5.0.1",
-    "ts-jest": "^29.1.0",
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.29.0",
+    "@babel/preset-react": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
+    "@commitlint/cli": "^20.5.3",
+    "@commitlint/config-angular": "^20.5.3",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^10.0.1",
+    "@ianvs/prettier-plugin-sort-imports": "^4.7.1",
+    "@jest/globals": "^30.3.0",
+    "@mic-rexjs/usecases": "^2.14.2",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^25.6.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@typescript-eslint/parser": "^8.59.2",
+    "babel-loader": "^10.1.1",
+    "copy-webpack-plugin": "^14.0.0",
+    "eslint": "^10.3.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-jest": "^29.15.2",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "globals": "^17.6.0",
+    "husky": "^9.1.7",
+    "jest": "^30.3.0",
+    "jest-environment-jsdom": "^30.3.0",
+    "lint-staged": "^17.0.2",
+    "prettier": "^3.8.3",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "rimraf": "^6.1.3",
+    "ts-jest": "^29.4.9",
     "ts-node": "^10.9.1",
-    "tsc-alias": "^1.8.7",
-    "typescript": "^5.1.5",
-    "webpack": "^5.74.0",
-    "webpack-cli": "^5.1.4"
+    "tsc-alias": "^1.8.17",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.2",
+    "webpack": "^5.106.2",
+    "webpack-cli": "^7.0.2"
   },
   "lint-staged": {
     "./**/*.{js,ts,tsx}": "eslint"

package/es/hooks/useCompareDeps/index.d.ts

@@ -1 +0,0 @@
-export declare const useCompareDeps: <T>(deps: T[]) => number;

package/es/hooks/useCompareDeps/index.js

@@ -1,11 +0,0 @@
-import { useRef } from 'react';
-import { isSameArray } from '../../methods/isSameArray';
-export const useCompareDeps = (deps) => {
-    const updateTimesRef = useRef(0);
-    const prevDepsRef = useRef([]);
-    const { current: prevDeps } = prevDepsRef;
-    const isSame = isSameArray(deps, prevDeps);
-    prevDepsRef.current = deps;
-    updateTimesRef.current += isSame ? 0 : 1;
-    return updateTimesRef.current;
-};

package/es/methods/cacheCall/index.d.ts

@@ -1,2 +0,0 @@
-import { CacheableFactory, CacheCallOptions } from './types';
-export declare const cacheCall: <T extends CacheableFactory>(factory: T, options?: CacheCallOptions) => T;

package/es/methods/cacheCall/index.js

@@ -1,26 +0,0 @@
-import { isSameArray } from '../isSameArray';
-export const cacheCall = (factory, options) => {
-    let cache;
-    const { onShouldCache = () => {
-        return true;
-    }, onCompare = (newArgs, oldArgs) => {
-        return isSameArray(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;
-    });
-};

package/es/methods/cacheCall/types.d.ts

@@ -1,13 +0,0 @@
-import { Reducer } from '@mic-rexjs/usecases';
-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 Reducer> {
-    parameters: Parameters<T>;
-    returnValue: ReturnType<T>;
-}

package/es/methods/cacheCalls/index.d.ts

@@ -1,2 +0,0 @@
-import { CacheCallOptions, CacheableFactory } from '../cacheCall/types';
-export declare const cacheCalls: <T extends Record<string, CacheableFactory>>(sourceFactories: T, options?: CacheCallOptions) => T;

package/es/methods/cacheCalls/index.js

@@ -1,8 +0,0 @@
-import { cacheCall } from '../cacheCall';
-export const cacheCalls = (sourceFactories, options) => {
-    const cachedFactories = {};
-    Object.entries(sourceFactories).forEach(([key, factory]) => {
-        cachedFactories[key] = cacheCall(factory, options);
-    });
-    return cachedFactories;
-};

package/es/methods/captureCalls/index.d.ts

@@ -1,2 +0,0 @@
-import { CaptureCallFactory } from './types';
-export declare const captureCalls: <T extends object>(obj: T, callback: CaptureCallFactory) => T;

package/es/methods/captureCalls/index.js

@@ -1,14 +0,0 @@
-export 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;
-};

package/es/methods/captureCalls/types.d.ts

@@ -1,4 +0,0 @@
-import { RestArguments } from '@mic-rexjs/usecases/es/types';
-export interface CaptureCallFactory {
-    <T>(key: string, args: RestArguments): T;
-}

package/es/methods/compareProperty/index.d.ts

@@ -1,2 +0,0 @@
-import { ComparePropertyCallback } from './types';
-export declare const compareProperty: <T, S>(from: T, to: S, fieldPath: string, callback: ComparePropertyCallback, fieldPathStack?: string[]) => void;

package/es/methods/compareProperty/index.js

@@ -1,34 +0,0 @@
-import { hasField } from '../hasField';
-export const compareProperty = (from, to, fieldPath, callback, fieldPathStack = []) => {
-    const undef = void 0;
-    const [, key = fieldPath, subFieldPath = ''] = fieldPath.match(/^([^.]+)\.(.+)$/) || [];
-    const hasFromField = hasField(from, key);
-    const hasToField = hasField(to, key);
-    const currentFieldPathStack = [...fieldPathStack, key];
-    if (hasFromField || hasToField) {
-        const fromValue = hasFromField ? from[key] : undef;
-        const toValue = hasToField ? to[key] : undef;
-        if (subFieldPath) {
-            compareProperty(fromValue, toValue, subFieldPath, callback, currentFieldPathStack);
-            return;
-        }
-        if (fromValue === toValue) {
-            return;
-        }
-        callback(fromValue, toValue, currentFieldPathStack);
-        return;
-    }
-    if (/^\d+^/.test(key)) {
-        return;
-    }
-    const fromArray = Array.isArray(from) ? from : [];
-    const toArray = Array.isArray(to) ? to : [];
-    const { length: fromLength } = fromArray;
-    const { length: toLength } = toArray;
-    const length = Math.max(fromLength, toLength);
-    for (let i = 0; i < length; i++) {
-        const fromItem = fromArray[i];
-        const toItem = toArray[i];
-        compareProperty(fromItem, toItem, fieldPath, callback, [...fieldPathStack, `${i}`]);
-    }
-};

package/es/methods/compareProperty/types.d.ts

@@ -1,3 +0,0 @@
-export interface ComparePropertyCallback {
-    <T, S>(fromValue: T, toValue: S, fieldPaths: string[]): void;
-}

package/es/methods/hasField/index.d.ts

@@ -1 +0,0 @@
-export declare const hasField: <T>(data: T, field: string) => boolean;

package/es/methods/hasField/index.js

@@ -1,6 +0,0 @@
-export const hasField = (data, field) => {
-    if (typeof data !== 'object' || data === null) {
-        return false;
-    }
-    return Object.hasOwn(data, field);
-};

package/es/methods/initEntityReducers/index.d.ts

@@ -1,5 +0,0 @@
-import { EntityStore } from '@mic-rexjs/usecases';
-import { UseCaseHookOptions } from '../../hooks/useUseCase/types';
-import { ContextualEntityReducers } from '../../usecases/contextUseCase/types';
-import { EntityReducerMap, InferableEntityUseCase } from '@mic-rexjs/usecases/es/types';
-export declare const initEntityReducers: <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object>(usecase: InferableEntityUseCase<T, TEntityReducers, TUseCaseOptions>, store: EntityStore<T>, options: UseCaseHookOptions<T, TUseCaseOptions>) => ContextualEntityReducers<T, TEntityReducers>;

package/es/methods/initEntityReducers/index.js

@@ -1,11 +0,0 @@
-import { createEntityReducers } from '@mic-rexjs/usecases';
-export const initEntityReducers = (usecase, store, options) => {
-    const { watch, onChange, options: usecaseOptions, ...restUseCaseOptions } = options;
-    return createEntityReducers(store, usecase, {
-        ...restUseCaseOptions,
-        ...usecaseOptions,
-        onGenerate(newEntity, result) {
-            return result;
-        },
-    });
-};

package/es/methods/isSameArray/index.d.ts

@@ -1 +0,0 @@
-export declare const isSameArray: (array1: unknown[], array2: unknown[]) => boolean;