@mic-rexjs/usecases-react 1.4.0 → 1.4.1

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/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/compareProperty/types.js

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

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/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/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 = {};