@mic-rexjs/usecases-react 1.4.0 → 1.5.0

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

@@ -5,15 +5,27 @@ export type CoreCollection<T, TEntityReducers extends EntityReducers<T>, TProvid
 export interface EntityGetter<T> {
     (): T;
 }
-export interface EntityWatcher<T> {
-    (newEntity: T, prevEntity: T): void;
+export interface EntityWatchEvent<T, TValue = unknown> {
+    fieldPaths: string[];
+    newEntity: T;
+    newValue: TValue;
+    oldEntity: T;
+    oldValue: TValue;
 }
-export type EntityWatchMap<T> = T extends unknown[] ? Record<number, EntityWatcher<T>> : T extends object ? {
-    [K in keyof T]?: EntityWatcher<T>;
-} : object;
+export interface EntityWatcher<T, TValue = unknown> {
+    (event: EntityWatchEvent<T, TValue>): void;
+}
+export type PropertyPath<T, K extends keyof T = keyof T & string> = K extends infer TKey ? `${TKey & (string | number)}${'' | DotAccessorFieldPath<T[TKey & keyof T]>}` : never;
+export type DotAccessorFieldPath<T> = T extends unknown[] ? '.length' | `${'' | `.${number}`}${DotAccessorFieldPath<T[number]>}` : T extends object ? `.${PropertyPath<T>}` : '';
+export type FieldPath<T> = T extends unknown[] ? FieldPath<T[number]> | 'length' : T extends object ? PropertyPath<T> : never;
+export type ExtractPropertyType<T, TPath> = TPath extends `${infer TKey}.${infer TSubPath}` ? T extends unknown[] ? ExtractPropertyType<T[number], TKey extends `${number}` ? TSubPath : TPath> : ExtractPropertyType<T[TKey & keyof T], TSubPath> : T extends unknown[] ? TPath extends 'length' ? T[TPath] : TPath extends `${number}` ? T[number] : ExtractPropertyType<T[number], TPath> : T[TPath & keyof T];
+export type ExtractFieldType<T, TPath> = TPath extends `${infer TKey}.${infer TSubProperty}` ? ExtractPropertyType<T[TKey & keyof T], TSubProperty> : T[TPath & keyof T];
+export type EntityWatchMap<T> = {
+    [K in FieldPath<T>]?: EntityWatcher<T, ExtractFieldType<T, K>>;
+};
 export interface UseCaseHookContextualOptions<T> {
     watch?: EntityWatchMap<T>;
-    onChange?(newEntity: T, prevEntity: T): void;
+    onChange?(newEntity: T, oldEntity: T): void;
 }
 export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extends UseCaseHookContextualOptions<T> {
     stateless?: boolean;

package/es/index.d.ts

@@ -1,4 +1,5 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
+export { useReducer } from './hooks/useReducer';
 export { useUseCase } from './hooks/useUseCase';
 export type { CoreCollection } from './hooks/useUseCase/types';
 export type { UseCaseHookOptions } from './hooks/useUseCase/types';

package/es/index.js

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

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,34 @@
+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

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

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

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

package/es/methods/hasField/index.js

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

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

@@ -1,3 +1,3 @@
 export interface EntityChangeEventHandler<T> {
-    (newEntity: T, prevEntity: T): void;
+    (newEntity: T, oldEntity: T): void;
 }

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

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

package/es/methods/isSameArray/index.js

@@ -0,0 +1,14 @@
+export const isSameArray = (array1, array2) => {
+    const { length: length1 } = array1;
+    const { length: length2 } = array2;
+    if (length1 !== length2) {
+        return false;
+    }
+    for (let i = 0; i < length1; i++) {
+        if (array1[i] === array2[i]) {
+            continue;
+        }
+        return false;
+    }
+    return true;
+};

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

@@ -1,3 +1,3 @@
 import { OptionsRefCollection } from '../../hooks/useOptionsRefCollection/types';
 import { UseCaseHookOptions } from '../../hooks/useUseCase/types';
-export declare const triggerCallbacks: <T, TUseCaseOptions extends object, TOptions extends UseCaseHookOptions<T, TUseCaseOptions> = UseCaseHookOptions<T, TUseCaseOptions>>(optionsRefCollection: OptionsRefCollection<TOptions>, newEntity: T, prevEntity: T) => void;
+export declare const triggerCallbacks: <T, TUseCaseOptions extends object, TOptions extends UseCaseHookOptions<T, TUseCaseOptions> = UseCaseHookOptions<T, TUseCaseOptions>>(optionsRefCollection: OptionsRefCollection<TOptions>, newEntity: T, oldEntity: T) => void;

package/es/methods/triggerCallbacks/index.js

@@ -1,5 +1,5 @@
 import { triggerWatchers } from '../triggerWatchers';
-export const triggerCallbacks = (optionsRefCollection, newEntity, prevEntity) => {
+export const triggerCallbacks = (optionsRefCollection, newEntity, oldEntity) => {
     for (let { length: i } = optionsRefCollection; i > 0; i--) {
         const { current: options } = optionsRefCollection[i - 1];
         if (!options) {
@@ -7,8 +7,8 @@ export const triggerCallbacks = (optionsRefCollection, newEntity, prevEntity) =>
         }
         const { onChange, watch } = options;
         if (watch) {
-            triggerWatchers(watch, newEntity, prevEntity);
+            triggerWatchers(watch, newEntity, oldEntity);
         }
-        onChange?.(newEntity, prevEntity);
+        onChange?.(newEntity, oldEntity);
     }
 };

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

@@ -1,2 +1,2 @@
 import { EntityWatchMap } from '../../hooks/useUseCase/types';
-export declare const triggerWatchers: <T>(watch: EntityWatchMap<T>, newEntity: T, prevEntity: T) => void;
+export declare const triggerWatchers: <T>(watch: EntityWatchMap<T>, newEntity: T, oldEntity: T) => void;

package/es/methods/triggerWatchers/index.js

@@ -1,10 +1,14 @@
-export const triggerWatchers = (watch, newEntity, prevEntity) => {
-    for (const [property, watcher] of Object.entries(watch)) {
-        const newValue = newEntity?.[property];
-        const prevValue = prevEntity?.[property];
-        if (newValue === prevValue) {
-            continue;
-        }
-        watcher(newEntity, prevEntity);
+import { compareProperty } from '../compareProperty';
+export const triggerWatchers = (watch, newEntity, oldEntity) => {
+    for (const [fieldPath, watcher] of Object.entries(watch)) {
+        compareProperty(oldEntity, newEntity, fieldPath, (oldValue, newValue, fieldPaths) => {
+            watcher({
+                fieldPaths,
+                newEntity,
+                oldEntity,
+                newValue,
+                oldValue,
+            });
+        });
     }
 };

package/lib/hooks/useCompareDeps/index.js

@@ -5,27 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useCompareDeps = void 0;
 var _react = require("react");
-var _useScope = require("../useScope");
+var _isSameArray = require("../../methods/isSameArray");
 var useCompareDeps = function useCompareDeps(deps) {
   var updateTimesRef = (0, _react.useRef)(0);
   var prevDepsRef = (0, _react.useRef)([]);
   var prevDeps = prevDepsRef.current;
-  var prevLength = prevDeps.length;
-  var length = deps.length;
-  var updated = (0, _useScope.useScope)(function () {
-    if (length !== prevLength) {
-      return true;
-    }
-    for (var i = 0; i < length; i++) {
-      if (deps[i] === prevDeps[i]) {
-        continue;
-      }
-      return true;
-    }
-    return false;
-  });
+  var isSame = (0, _isSameArray.isSameArray)(deps, prevDeps);
   prevDepsRef.current = deps;
-  updateTimesRef.current += updated ? 1 : 0;
+  updateTimesRef.current += isSame ? 0 : 1;
   return updateTimesRef.current;
 };
 exports.useCompareDeps = useCompareDeps;

package/lib/hooks/useReducer/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useReducer = void 0;
+var _isSameArray = require("../../methods/isSameArray");
+var _ahooks = require("ahooks");
+var _react = require("react");
+var useReducer = function useReducer(reducer) {
+  var prevReducerRef = (0, _react.useRef)();
+  var prevArgsRef = (0, _react.useRef)([]);
+  var prevReturnValueRef = (0, _react.useRef)();
+  return (0, _ahooks.useMemoizedFn)(function () {
+    var returnValue = prevReturnValueRef.current;
+    var prevReducer = prevReducerRef.current;
+    var prevArgs = prevArgsRef.current;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (reducer !== prevReducer || !(0, _isSameArray.isSameArray)(args, prevArgs)) {
+      returnValue = reducer.apply(void 0, args);
+    }
+    prevReducerRef.current = reducer;
+    prevArgsRef.current = args;
+    prevReturnValueRef.current = returnValue;
+    return returnValue;
+  });
+};
+exports.useReducer = useReducer;

package/lib/hooks/useUseCase/index.js

@@ -51,11 +51,11 @@ var useUseCase = function useUseCase(arg1, arg2, arg3, arg4) {
     }
     return (0, _getRootEntity.getRootEntity)(entityState, arg1, stateless);
   }, [hasInitialEntity, contextEntity, stateless, entityState, arg1]);
-  var onEntityChange = (0, _ahooks.useMemoizedFn)(function (newEntity, prevEntity) {
+  var onEntityChange = (0, _ahooks.useMemoizedFn)(function (newEntity, oldEntity) {
     if (!stateless) {
       setEntityState(newEntity);
     }
-    (0, _triggerCallbacks.triggerCallbacks)(optionsRefCollection, newEntity, prevEntity);
+    (0, _triggerCallbacks.triggerCallbacks)(optionsRefCollection, newEntity, oldEntity);
   });
   var createReducers = (0, _ahooks.useMemoizedFn)(function () {
     var reducers = {};