@mic-rexjs/usecases-react 3.3.0 → 3.6.2

package/es/hooks/useUseCase/index.js

@@ -1,7 +1,6 @@
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { useArgumentTypes } from '../useArgumentTypes';
 import { useConstantFn } from '../useConstantFn';
-import { useConstantReducers } from '../useConstantReducers';
 import { useContext } from '../useContext';
 import { useEntity } from '../useEntity';
 import { useFullArguments } from '../useFullArguments';
@@ -25,20 +24,20 @@ export const useUseCase = function () {
     unsafeUsecase = _fullArguments[1],
     options = _fullArguments[2],
     deps = _fullArguments[3];
-  const _useConstantReducers = useConstantReducers(methodUseCase),
-    cacheCalls = _useConstantReducers.cacheCalls;
   const usecase = useConstantFn(unsafeUsecase);
   const context = useContext(usecase, argumentTypes);
   const entityContext = context;
   const statuses = useStatuses(context, argumentTypes);
-  const store = useStore(unsafeEntity, entityContext, statuses, options, deps);
+  const store = useStore(unsafeEntity, entityContext, statuses, deps);
   const reducers = useReducers(usecase, context, store, statuses, options, deps);
-  const entity = useEntity(unsafeEntity, store, reducers, statuses, options);
+  const entity = useEntity(store, statuses, options);
   const Provider = useProvider(statuses, context, store, reducers);
   return useCreation(() => {
     if ((statuses & Statuses.EntityEnabled) !== Statuses.EntityEnabled) {
       return reducers;
     }
+    const _methodUseCase = methodUseCase(),
+      cacheCalls = _methodUseCase.cacheCalls;
     const cachedReducers = cacheCalls(reducers, {
       onShouldCache() {
         return isRenderingRef.current;
@@ -53,5 +52,5 @@ export const useUseCase = function () {
       ...entity
     } : entity;
     return [newEntity, cachedReducers, Provider];
-  }, [statuses, entity, reducers, Provider, isRenderingRef, cacheCalls]);
+  }, [statuses, entity, reducers, Provider, isRenderingRef]);
 };

package/es/hooks/useUseCase/index.test.js

@@ -9,6 +9,7 @@ import { act, render, renderHook } from '@testing-library/react';
 import { useDeepCompareEffect, useMemoizedFn, useMount, useUpdate, useUpdateEffect } from 'ahooks';
 import { Fragment, useEffect, useMemo, useRef, useState } from 'react';
 import { createPortal } from 'react-dom';
+import { lifecycleUseCase } from '../../usecases/lifecycleUseCase';
 const EXT_1 = '.png';
 const EXT_2 = '.jpg';
 const PATH_1 = `hello${EXT_1}`;
@@ -1998,15 +1999,16 @@ describe('useUseCase', () => {
       expect(onStringMount).toHaveBeenCalledWith('hello');
       expect(onBooleanMount).toHaveBeenCalledWith(true);
     });
-    test('`bindEntity` should be called when component mount', () => {
-      const bindEntity = jest.fn(entity => {
+    test('`onBind` event should be called when component mount', () => {
+      const onBind = jest.fn(entity => {
         void entity;
       });
       const testUseCase = () => {
-        const entityReducers = entityUseCase();
+        const lifecycleReducers = lifecycleUseCase({
+          onBind
+        });
         return {
-          ...entityReducers,
-          bindEntity
+          ...lifecycleReducers
         };
       };
       renderHook(() => {
@@ -2017,21 +2019,76 @@ describe('useUseCase', () => {
           setEntity(100);
         });
       });
-      expect(bindEntity).toHaveBeenCalledTimes(1);
-      expect(bindEntity).toHaveBeenCalledWith(5);
+      expect(onBind).toHaveBeenCalledTimes(1);
+      expect(onBind).toHaveBeenCalledWith(5);
     });
-    test('`unbindEntity` should be called when component unmount', () => {
-      const unbindEntity = jest.fn(entity => {
-        void entity;
+    test('`onChange` event should be called when entity change', () => {
+      const onChange = jest.fn((newEntity, oldEntity) => {
+        void newEntity;
+        void oldEntity;
       });
       const testUseCase = () => {
-        const entityReducers = entityUseCase();
+        const lifecycleReducers = lifecycleUseCase({
+          onChange
+        });
         return {
-          ...entityReducers,
-          unbindEntity
+          ...lifecycleReducers
         };
       };
       const _renderHook37 = renderHook(() => {
+          return useUseCase(5, testUseCase);
+        }),
+        result = _renderHook37.result;
+      const current = result.current;
+      const _current8 = _slicedToArray(current, 2),
+        setEntity = _current8[1].setEntity;
+      expect(onChange).toHaveBeenCalledTimes(0);
+      act(() => {
+        setEntity(100);
+      });
+      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledWith(100, 5);
+    });
+    test('`onUpdate` event should be called when entity change', () => {
+      const onUpdate = jest.fn((newEntity, oldEntity) => {
+        void newEntity;
+        void oldEntity;
+      });
+      const testUseCase = () => {
+        const lifecycleReducers = lifecycleUseCase({
+          onUpdate
+        });
+        return {
+          ...lifecycleReducers
+        };
+      };
+      const _renderHook38 = renderHook(() => {
+          return useUseCase(5, testUseCase);
+        }),
+        result = _renderHook38.result;
+      const current = result.current;
+      const _current9 = _slicedToArray(current, 2),
+        setEntity = _current9[1].setEntity;
+      expect(onUpdate).toHaveBeenCalledTimes(0);
+      act(() => {
+        setEntity(100);
+      });
+      expect(onUpdate).toHaveBeenCalledTimes(1);
+      expect(onUpdate).toHaveBeenCalledWith(100, 5);
+    });
+    test('`onUnbind` event should be called when component unmount', () => {
+      const onUnbind = jest.fn(entity => {
+        void entity;
+      });
+      const testUseCase = () => {
+        const lifecycleReducers = lifecycleUseCase({
+          onUnbind
+        });
+        return {
+          ...lifecycleReducers
+        };
+      };
+      const _renderHook39 = renderHook(() => {
           const _useUseCase26 = useUseCase(5, testUseCase),
             _useUseCase27 = _slicedToArray(_useUseCase26, 2),
             setEntity = _useUseCase27[1].setEntity;
@@ -2039,11 +2096,11 @@ describe('useUseCase', () => {
             setEntity(100);
           });
         }),
-        unmount = _renderHook37.unmount;
-      expect(unbindEntity).toHaveBeenCalledTimes(0);
+        unmount = _renderHook39.unmount;
+      expect(onUnbind).toHaveBeenCalledTimes(0);
       unmount();
-      expect(unbindEntity).toHaveBeenCalledTimes(1);
-      expect(unbindEntity).toHaveBeenCalledWith(100);
+      expect(onUnbind).toHaveBeenCalledTimes(1);
+      expect(onUnbind).toHaveBeenCalledWith(100);
     });
   });
   describe('`useUseCase` should work the same as `useContextualCoreCollection`', () => {
@@ -2606,38 +2663,38 @@ describe('useUseCase', () => {
   });
   describe('`useUseCase` should work the same as `useReducers`', () => {
     test('`entity` should equal `defaultFile`', () => {
-      const _renderHook38 = renderHook(() => {
+      const _renderHook40 = renderHook(() => {
           return useUseCase(mathUseCase);
         }),
-        result = _renderHook38.result;
+        result = _renderHook40.result;
       const reducers = result.current;
       expect(Array.isArray(reducers)).toBe(false);
     });
     test('returned reducer should work', () => {
-      const _renderHook39 = renderHook(() => {
+      const _renderHook41 = renderHook(() => {
           return useUseCase(mathUseCase);
         }),
-        result = _renderHook39.result;
+        result = _renderHook41.result;
       const reducers = result.current;
       const add = reducers.add;
       expect(add(1, 2)).toBe(3);
     });
     test('`usecase` should be called only once if deps has not provided', () => {
       const mockUseCase = jest.fn(mathUseCase);
-      const _renderHook40 = renderHook(() => {
+      const _renderHook42 = renderHook(() => {
           return useUseCase(mockUseCase);
         }),
-        rerender = _renderHook40.rerender;
+        rerender = _renderHook42.rerender;
       expect(mockUseCase).toHaveBeenCalledTimes(1);
       rerender();
       expect(mockUseCase).toHaveBeenCalledTimes(1);
     });
     test('`usecase` should be called only once if deps has not changed', () => {
       const mockUseCase = jest.fn(mathUseCase);
-      const _renderHook41 = renderHook(() => {
+      const _renderHook43 = renderHook(() => {
           return useUseCase(mockUseCase, {}, [1, 'x']);
         }),
-        rerender = _renderHook41.rerender;
+        rerender = _renderHook43.rerender;
       expect(mockUseCase).toHaveBeenCalledTimes(1);
       rerender();
       expect(mockUseCase).toHaveBeenCalledTimes(1);
@@ -2645,10 +2702,10 @@ describe('useUseCase', () => {
     test('`usecase` should be called if deps has changed', () => {
       let i = 0;
       const mockUseCase = jest.fn(mathUseCase);
-      const _renderHook42 = renderHook(() => {
+      const _renderHook44 = renderHook(() => {
           return useUseCase(mockUseCase, {}, [i++, 'x']);
         }),
-        rerender = _renderHook42.rerender;
+        rerender = _renderHook44.rerender;
       expect(mockUseCase).toHaveBeenCalledTimes(1);
       rerender();
       expect(mockUseCase).toHaveBeenCalledTimes(2);
@@ -2732,12 +2789,12 @@ describe('useUseCase', () => {
       expect(subtractionReducer).toHaveReturnedWith(4);
     });
     test('`options.extraValue` should be added after call `add` method', () => {
-      const _renderHook43 = renderHook(() => {
+      const _renderHook45 = renderHook(() => {
           return useUseCase(mathUseCase, {
             extraValue: 5
           });
         }),
-        result = _renderHook43.result;
+        result = _renderHook45.result;
       const reducers = result.current;
       const add = reducers.add;
       expect(add(1, 2)).toBe(8);
@@ -2745,7 +2802,7 @@ describe('useUseCase', () => {
     test('when `options` has changed, it should not trigger update', () => {
       const onUpdate = jest.fn();
       const onDeepUpdate = jest.fn();
-      const _renderHook44 = renderHook(() => {
+      const _renderHook46 = renderHook(() => {
           const _useState7 = useState(0),
             _useState8 = _slicedToArray(_useState7, 2),
             extraValue = _useState8[0],
@@ -2761,7 +2818,7 @@ describe('useUseCase', () => {
           }, [reducers]);
           return setExtraValue;
         }),
-        result = _renderHook44.result;
+        result = _renderHook46.result;
       expect(onUpdate).toHaveBeenCalledTimes(0);
       expect(onDeepUpdate).toHaveBeenCalledTimes(0);
       act(() => {
@@ -2773,7 +2830,7 @@ describe('useUseCase', () => {
     test('when `deps` change, it should update reducers', () => {
       const onUpdate = jest.fn();
       const onDeepUpdate = jest.fn();
-      const _renderHook45 = renderHook(() => {
+      const _renderHook47 = renderHook(() => {
           const _useState9 = useState(0),
             _useState0 = _slicedToArray(_useState9, 2),
             extraValue = _useState0[0],
@@ -2789,7 +2846,7 @@ describe('useUseCase', () => {
           }, [reducers]);
           return setExtraValue;
         }),
-        result = _renderHook45.result;
+        result = _renderHook47.result;
       expect(onUpdate).toHaveBeenCalledTimes(0);
       expect(onDeepUpdate).toHaveBeenCalledTimes(0);
       act(() => {
@@ -2801,7 +2858,7 @@ describe('useUseCase', () => {
     test('empty `deps` should not update reducers', () => {
       const onUpdate = jest.fn();
       const onDeepUpdate = jest.fn();
-      const _renderHook46 = renderHook(() => {
+      const _renderHook48 = renderHook(() => {
           const _useState1 = useState(0),
             _useState10 = _slicedToArray(_useState1, 2),
             extraValue = _useState10[0],
@@ -2817,7 +2874,7 @@ describe('useUseCase', () => {
           }, [reducers]);
           return setExtraValue;
         }),
-        result = _renderHook46.result;
+        result = _renderHook48.result;
       expect(onUpdate).toHaveBeenCalledTimes(0);
       expect(onDeepUpdate).toHaveBeenCalledTimes(0);
       act(() => {

package/es/index.d.ts

@@ -1,9 +1,9 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
-export { lifeCycleUseCase } from './usecases/lifeCycleUseCase';
+export { lifecycleUseCase } from './usecases/lifecycleUseCase';
 export { useProviders } from './hooks/useProviders';
 export type { EntityWatchEvent, RootCoreCollection, ContextualCoreCollection, CoreCollection, } from './hooks/useUseCase/types';
 export type { UseCaseHookOptions } from './hooks/useUseCase/types';
 export type { UseCaseProvider } from './hooks/useProvider/types';
-export type { LifeCycleReducers, LifeCycleUseCaseOptions } from './usecases/lifeCycleUseCase/types';
+export type { LifecycleReducers, LifecycleUseCaseOptions } from './usecases/lifecycleUseCase/types';
 export type { UseCaseFragmentProps } from './components/UseCaseFragment/types';

package/es/index.js

@@ -1,4 +1,4 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
-export { lifeCycleUseCase } from './usecases/lifeCycleUseCase';
+export { lifecycleUseCase } from './usecases/lifecycleUseCase';
 export { useProviders } from './hooks/useProviders';

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

@@ -0,0 +1,3 @@
+import { EntityStore } from '@mic-rexjs/usecases';
+import { EntityInitializer } from '../../types';
+export declare const runEntityInitializer: <T>(store: EntityStore<T>, initializer: EntityInitializer<T>, prevCreateEntityList: Partial<T>[], isInitializing: boolean) => Partial<T>[];

package/es/methods/runEntityInitializer/index.js

@@ -0,0 +1,67 @@
+import { createEntity, createEntityReducers } from '@mic-rexjs/usecases';
+import { entityRuntimeUseCase } from '../../usecases/entityRuntimeUseCase';
+import { objectUtilsUseCase } from '../../usecases/objectUtilsUseCase';
+export const runEntityInitializer = (store, initializer, prevCreateEntityList, isInitializing) => {
+  let isAsync = false;
+  let index = 0;
+  const createEntityList = [];
+  const _objectUtilsUseCase = objectUtilsUseCase(),
+    isObject = _objectUtilsUseCase.isObject,
+    isEqual = _objectUtilsUseCase.isEqual;
+  const onInitStoreValue = value => {
+    if (!isInitializing || isAsync) {
+      return value;
+    }
+    return store.initValue(value);
+  };
+  const _createEntityReducers = createEntityReducers(store, entityRuntimeUseCase, {
+      onInit(currentValue) {
+        return initializer(currentValue);
+      },
+      onCreate(newEntity, oldEntity) {
+        const currentIndex = index;
+        const isObj = isObject(oldEntity);
+        const isArray = isObj && Array.isArray(oldEntity);
+        index++;
+        createEntityList[currentIndex] = newEntity;
+        if (!isObj || isArray) {
+          return createEntity(oldEntity, newEntity);
+        }
+        const descriptors = {};
+        const prevEntity = prevCreateEntityList[currentIndex];
+        isEqual(prevEntity, newEntity, key => {
+          const descriptor = Object.getOwnPropertyDescriptor(newEntity, key) || null;
+          if (descriptor === null) {
+            return;
+          }
+          descriptors[key] = descriptor;
+        });
+        return createEntity(oldEntity, Object.defineProperties({}, descriptors));
+      },
+      onGenerate(entity, result) {
+        if (typeof result === 'undefined') {
+          return [entity, result];
+        }
+        const newResult = createEntity(entity, result);
+        // 不能用 `store.value`，因为可能存在异步，异步更新是需要触发组件更新的
+        store.setValue(newResult);
+        return [newResult, result];
+      },
+      onYield(entity) {
+        return onInitStoreValue(entity);
+      },
+      onReturn(entity) {
+        const newEntity = onInitStoreValue(entity);
+        // 不能用 `store.value`，因为可能存在异步，异步更新是需要触发组件更新的
+        store.setValue(newEntity);
+        return newEntity;
+      }
+    }),
+    initEntity = _createEntityReducers.initEntity;
+  // 禁用 `store` 的事件，避免触发 `onChange`
+  store.disableWatchers();
+  initEntity();
+  store.enableWatchers();
+  isAsync = true;
+  return createEntityList;
+};

package/es/methods/triggerWatchers/index.js

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

package/es/usecases/lifecycleEventUseCase/index.d.ts

@@ -0,0 +1,3 @@
+import { LifecycleEventReducers } from './types';
+import { UseCase } from '@mic-rexjs/usecases';
+export declare const lifecycleEventUseCase: UseCase<LifecycleEventReducers, object>;

package/es/usecases/lifecycleEventUseCase/index.js

@@ -0,0 +1,34 @@
+import { createUseCase } from '@mic-rexjs/usecases';
+export const lifecycleEventUseCase = createUseCase(() => {
+  const map = new Map();
+  let events = null;
+  /**
+   * 逻辑是：先存，再绑定 `key`，再通过 `key` 获取，最后清除
+   */
+  return () => {
+    const deleteLifecycleEvents = key => {
+      return map.delete(key);
+    };
+    const bindLifecycleEventsKey = key => {
+      if (events === null) {
+        return {};
+      }
+      const currentEvents = events;
+      events = null;
+      map.set(key, currentEvents);
+      return currentEvents;
+    };
+    const getLifecycleEvents = key => {
+      return map.get(key) || {};
+    };
+    const setLifecycleEvents = e => {
+      events = e;
+    };
+    return {
+      deleteLifecycleEvents,
+      setLifecycleEvents,
+      getLifecycleEvents,
+      bindLifecycleEventsKey
+    };
+  };
+});

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

@@ -0,0 +1,36 @@
+import { Reducers } from '@mic-rexjs/usecases';
+export interface LifecycleEvents<T = unknown> {
+    /**
+     * 在渲染组件阶段触发：
+     *
+     * 第一次初始化，将 `entity` 与 `reducers` 相绑定的时候触发，仅一次。
+     */
+    onBind(entity: T): void;
+    /**
+     * `unmount` 的时候触发。
+     */
+    onUnbind(entity: T): void;
+    /**
+     * 非渲染阶段触发，随后会触发组件的更新：
+     *
+     * 只由相关 `reducers` 的调用行为触发；
+     * 不包括 `useUseCase(entity, usecase)` 中的 `entity` 变化触发。
+     */
+    onChange(newEntity: T, oldEntity: T): void;
+    /**
+     * 触发机制包括以下两点：
+     *
+     * 1. 由相关 `reducers` 的调用行为触发 - 非渲染阶段；
+     * 2. 由 `useUseCase(entity, usecase)` 中的 `entity` 变化触发 - 渲染阶段。
+     */
+    onUpdate(newEntity: T, oldEntity: T): void;
+}
+export interface CaptureLifecycleEventsCallback<T> {
+    (): T;
+}
+export type LifecycleEventReducers = Reducers<{
+    deleteLifecycleEvents(key: React.Key): boolean;
+    bindLifecycleEventsKey<T>(key: React.Key): Partial<LifecycleEvents<T>>;
+    setLifecycleEvents<T>(events: Partial<LifecycleEvents<T>>): void;
+    getLifecycleEvents<T>(key: React.Key): Partial<LifecycleEvents<T>>;
+}>;

package/es/usecases/lifecycleEventUseCase/types.js

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

package/es/usecases/lifecycleUseCase/index.d.ts

@@ -0,0 +1,2 @@
+import { LifecycleReducers, LifecycleUseCaseOptions } from './types';
+export declare const lifecycleUseCase: <T>(options?: LifecycleUseCaseOptions<T>) => LifecycleReducers<T>;

package/es/usecases/lifecycleUseCase/index.js

@@ -0,0 +1,21 @@
+import { lifecycleEventUseCase } from '../lifecycleEventUseCase';
+import { entityUseCase } from '@mic-rexjs/usecases';
+export const lifecycleUseCase = function () {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const onBind = options.onBind,
+    onUnbind = options.onUnbind,
+    onChange = options.onChange,
+    onUpdate = options.onUpdate;
+  const _lifecycleEventUseCas = lifecycleEventUseCase(),
+    setLifecycleEvents = _lifecycleEventUseCas.setLifecycleEvents;
+  const entityReducers = entityUseCase();
+  setLifecycleEvents({
+    onBind,
+    onUnbind,
+    onChange,
+    onUpdate
+  });
+  return {
+    ...entityReducers
+  };
+};

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

@@ -0,0 +1,5 @@
+import { LifecycleEvents } from '../lifecycleEventUseCase/types';
+import { EntityReducers } from '@mic-rexjs/usecases';
+export interface LifecycleUseCaseOptions<T> extends Partial<LifecycleEvents<T>> {
+}
+export type LifecycleReducers<T> = EntityReducers<T, Record<never, never>>;

package/es/usecases/lifecycleUseCase/types.js

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

package/es/usecases/methodUseCase/index.js

@@ -1,8 +1,8 @@
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import { valueUseCase } from '../valueUseCase';
+import { objectUtilsUseCase } from '../objectUtilsUseCase';
 export const methodUseCase = () => {
-  const _valueUseCase = valueUseCase(),
-    matchValue = _valueUseCase.matchValue;
+  const _objectUtilsUseCase = objectUtilsUseCase(),
+    isEqual = _objectUtilsUseCase.isEqual;
   const cacheCall = (factory, options) => {
     let cache;
     const _ref = options || {},
@@ -12,7 +12,7 @@ export const methodUseCase = () => {
       } : _ref$onShouldCache,
       _ref$onCompare = _ref.onCompare,
       onCompare = _ref$onCompare === void 0 ? (newArgs, oldArgs) => {
-        return matchValue(newArgs, oldArgs);
+        return isEqual(newArgs, oldArgs);
       } : _ref$onCompare;
     return function () {
       const cacheable = onShouldCache();

package/es/usecases/objectUtilsUseCase/index.d.ts

@@ -0,0 +1,2 @@
+import { ObjectUtilsReducers } from './types';
+export declare const objectUtilsUseCase: () => ObjectUtilsReducers;