@mic-rexjs/usecases-react 4.0.0-beta.0 → 4.0.0-beta.4

package/es/hooks/useRootInitializing/index.js

@@ -0,0 +1,14 @@
+import { useReturn } from '../useReturn';
+import { useRef } from 'react';
+import { Statuses } from '../../enums/Statuses';
+export const useRootInitializing = statuses => {
+  const rootKey = statuses & Statuses.RootKey;
+  const isInitializingRef = useRef(true);
+  return useReturn(() => {
+    const isInitializing = isInitializingRef.current;
+    isInitializingRef.current = false;
+    return isInitializing;
+  }, () => {
+    isInitializingRef.current = true;
+  }, [rootKey]);
+};

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

@@ -0,0 +1,5 @@
+import { RootReturnHook } from './types';
+/**
+ * 只有 `ReducersHook` 或 `RootCoreCollectionHook` 模式下才执行相关回调
+ */
+export declare const useRootReturn: RootReturnHook;

package/es/hooks/useRootReturn/index.js

@@ -0,0 +1,22 @@
+import { useIfReturn } from '../useIfReturn';
+import { Statuses } from '../../enums/Statuses';
+/**
+ * 只有 `ReducersHook` 或 `RootCoreCollectionHook` 模式下才执行相关回调
+ */
+export const useRootReturn = (statuses, callback, arg3, arg4, arg5) => {
+  const isDepsArg3 = Array.isArray(arg3);
+  const isDepsArg4 = Array.isArray(arg4);
+  const isStatusesArg3 = typeof arg3 === 'number';
+  const isStatusesArg4 = typeof arg4 === 'number';
+  const destructor = !isDepsArg3 && !isStatusesArg3 ? arg3 : null;
+  const rootStatuses = isStatusesArg3 ? arg3 : isStatusesArg4 ? arg4 : Statuses.RootRuntime;
+  const deps = isDepsArg3 ? arg3 : isDepsArg4 ? arg4 : arg5 || [];
+  const rootKey = statuses & Statuses.RootKey;
+  const rootCalled = (statuses & rootStatuses) === rootStatuses;
+  const isEntityRootRuntime = (statuses & Statuses.EntityRootRuntime) === Statuses.EntityRootRuntime;
+  return useIfReturn(rootCalled, () => {
+    return callback(isEntityRootRuntime);
+  }, () => {
+    destructor === null || destructor === void 0 || destructor(isEntityRootRuntime);
+  }, [rootKey, ...deps]);
+};

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

@@ -0,0 +1,14 @@
+import { Statuses } from '../../enums/Statuses';
+import { Dependencies } from '../../types';
+export interface RootReturnCallback<T> {
+    (isEntityRootRuntime: boolean): T;
+}
+export interface RootReturnDestructor {
+    (isEntityRootRuntime: boolean): void;
+}
+export interface RootReturnHook {
+    <T>(statuses: Statuses, callback: RootReturnCallback<T>, deps?: Dependencies): T | null;
+    <T>(statuses: Statuses, callback: RootReturnCallback<T>, rootStatuses?: Statuses, deps?: Dependencies): T | null;
+    <T>(statuses: Statuses, callback: RootReturnCallback<T>, destructor: RootReturnDestructor | null, deps?: Dependencies): T | null;
+    <T>(statuses: Statuses, callback: RootReturnCallback<T>, destructor: RootReturnDestructor | null, rootStatuses?: Statuses, deps?: Dependencies): T | null;
+}

package/es/hooks/useRootReturn/types.js

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

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

@@ -1,5 +1,5 @@
-import { ReducerMap } from '@mic-rexjs/usecases/es/types';
-import { ArgumentTypes } from '../../enums/ArgumentTypes';
+import { FullParameters } from '../useFullArguments/types';
 import { Statuses } from '../../enums/Statuses';
-import { UseCaseContext, UseCaseContextValue } from '../../usecases/contextUseCase/types';
-export declare const useStatuses: <T extends ReducerMap>(context: UseCaseContext<UseCaseContextValue<T>>, argumentTypes: ArgumentTypes) => Statuses;
+import { UnknownReducerMap } from '../../types';
+import { EntityUseCaseContextValue, UseCaseContext } from '../../usecases/contextUseCase/types';
+export declare const useStatuses: <T, TReducers extends UnknownReducerMap<T>, TUseCaseOptions extends object>(fullArguments: FullParameters<T, TReducers, TUseCaseOptions>, context: UseCaseContext<EntityUseCaseContextValue<T, TReducers>>, isEntityRoot: boolean) => Statuses;

package/es/hooks/useStatuses/index.js

@@ -1,25 +1,50 @@
-import { useCreation } from 'ahooks';
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useAlternateStatuses } from '../useAlternateStatuses';
+import { useDepsKey } from '../useDepsKey';
 import { useContext } from 'react';
-import { ArgumentTypes } from '../../enums/ArgumentTypes';
 import { Statuses } from '../../enums/Statuses';
-export const useStatuses = (context, argumentTypes) => {
+// 遵循一个要求：参数不变，`statuses` 的计算结果不能变
+export const useStatuses = (fullArguments, context, isEntityRoot) => {
+  let statuses = Statuses.None;
+  const _fullArguments = _slicedToArray(fullArguments, 4),
+    entity = _fullArguments[0],
+    usecase = _fullArguments[1],
+    deps = _fullArguments[3];
+  const isInitializer = typeof entity === 'function';
   const contextValue = useContext(context);
-  return useCreation(() => {
-    let statuses = Statuses.None;
-    const _ref = contextValue || {},
-      store = _ref.store;
-    const hasEntity = (argumentTypes & ArgumentTypes.Entity) === ArgumentTypes.Entity;
-    if (hasEntity) {
-      statuses |= Statuses.EntityRootEnabled;
-    }
-    if (contextValue) {
-      statuses |= Statuses.ContextEnabled;
-    } else {
-      statuses |= Statuses.RootEnabled;
-    }
-    if (store) {
-      statuses |= Statuses.EntityEnabled;
-    }
-    return statuses;
-  }, [argumentTypes, contextValue]);
+  const isEntityContext = !isEntityRoot && contextValue !== null;
+  const _ref = isEntityContext ? contextValue : {
+      key: isEntityRoot ? Statuses.RootX : Statuses.RootY
+    },
+    key = _ref.key;
+  const depsKey = useDepsKey(deps);
+  const rootKey = useDepsKey([usecase, key]);
+  const reducersKey = useDepsKey([rootKey, depsKey]);
+  const rootStatuses = useAlternateStatuses(rootKey, Statuses.RootX, Statuses.RootY);
+  const usecaseStatuses = useAlternateStatuses(usecase, Statuses.UseCaseX, Statuses.UseCaseY);
+  const reducersStatuses = useAlternateStatuses(reducersKey, Statuses.ReducersX, Statuses.ReducersY);
+  const depsStatuses = useAlternateStatuses(depsKey, Statuses.DepsX, Statuses.DepsY);
+  const initialEntityStatuses = useAlternateStatuses(isInitializer ? reducersKey : entity, Statuses.InitialEntityX, Statuses.InitialEntityY);
+  switch (true) {
+    case isEntityRoot:
+      // `entity` 参数，只有 `entity root` 模式才有
+      statuses |= initialEntityStatuses;
+      statuses |= Statuses.EntityRootRuntime;
+      break;
+    case isEntityContext:
+      statuses |= Statuses.EntityContextRuntime;
+      break;
+    default:
+      statuses |= Statuses.RootRuntime;
+      break;
+  }
+  // `root` 是肯定有的，要么自身为 `root`，要么上下文有 `root`
+  statuses |= rootStatuses;
+  // `usecase` 作为标识符参数，也是肯定有的
+  statuses |= usecaseStatuses;
+  // `reducers` 作为 `usecase` 的产物，也是肯定有的
+  statuses |= reducersStatuses;
+  // `deps` 虽然是可选参数，但是默认值是空数组 `[]`，所以也是肯定有的
+  statuses |= depsStatuses;
+  return statuses;
 };

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

@@ -1,5 +1,5 @@
-import { EntityReducers, EntityStore } from '@mic-rexjs/usecases';
+import { EntityStore } from '@mic-rexjs/usecases';
 import { Statuses } from '../../enums/Statuses';
-import { Dependencies, EntityInitializer } from '../../types';
+import { EntityInitializer, UnknownReducerMap } from '../../types';
 import { EntityUseCaseContextValue, UseCaseContext } from '../../usecases/contextUseCase/types';
-export declare const useStore: <T>(entityArg: T | EntityInitializer<T>, context: UseCaseContext<EntityUseCaseContextValue<T, EntityReducers<T>>>, statuses: Statuses, deps?: Dependencies) => EntityStore<T>;
+export declare const useStore: <T, TReducers extends UnknownReducerMap<T>>(entityArg: T | EntityInitializer<T>, context: UseCaseContext<EntityUseCaseContextValue<T, TReducers>>, statuses: Statuses) => EntityStore<T>;

package/es/hooks/useStore/index.js

@@ -1,63 +1,40 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import { useContextualItem } from '../useContextualItem';
-import { useEntityInitializing } from '../useEntityInitializing';
-import { useExec } from '../useExec';
+import { useEntityRootExec } from '../useEntityRootExec';
+import { useRootInitializing } from '../useRootInitializing';
+import { useRootReturn } from '../useRootReturn';
 import { EntityStore } from '@mic-rexjs/usecases';
-import { usePrevious } from 'ahooks';
-import { useContext, useRef, useState } from 'react';
+import { useContext, useRef } from 'react';
 import { Statuses } from '../../enums/Statuses';
 import { runEntityInitializer } from '../../methods/runEntityInitializer';
-export const useStore = function (entityArg, context, statuses) {
-  let deps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-  const isFunction = typeof entityArg === 'function';
-  const isInitializing = useEntityInitializing(statuses);
+export const useStore = (entityArg, context, statuses) => {
   const createEntityListRef = useRef([]);
+  const isInitializing = useRootInitializing(statuses);
   const contextValue = useContext(context);
   const _ref = contextValue || {},
     _ref$store = _ref.store,
     contextStore = _ref$store === void 0 ? null : _ref$store;
-  const entityRootEnabled = (statuses & Statuses.EntityRootEnabled) === Statuses.EntityRootEnabled;
-  const _useState = useState(() => {
-      return new EntityStore(void 0);
-    }),
-    _useState2 = _slicedToArray(_useState, 1),
-    store = _useState2[0];
-  const prevEntityArg = usePrevious(entityArg, () => {
-    return true;
+  const initialEntityKey = statuses & Statuses.InitialEntityKey;
+  const rootStore = useRootReturn(statuses, () => {
+    return new EntityStore(void 0);
   });
-  /**
-   * 这里只有初始化和 `deps` 变化时，才会执行；
-   * 比如：`useUseCase(entityInitailizer, usecase, options, [key])`，
-   * 当首次调用 `entityInitailizer` 或 `key` 变化，才会触发以下事件
-   */
+  const store = rootStore || contextStore;
   const onRunInitializer = () => {
+    if (!isInitializing) {
+      return;
+    }
     const createEntityList = createEntityListRef.current;
     createEntityListRef.current = runEntityInitializer(store, entityArg, createEntityList, isInitializing);
   };
-  /**
-   * 这里仅仅是将非函数的 `entity` 同步；
-   *
-   * 比如 `useUseCase(entity, usecase)`，
-   * 当传入的 `entity` 变化时，执行一下同步操作。
-   */
-  useExec(() => {
-    switch (true) {
-      case !entityRootEnabled:
-      case isFunction:
-        return;
-      case isInitializing:
-        store.initValue(entityArg);
-        return;
-      case entityArg === prevEntityArg:
-        return;
-    }
-    // 执行同步操作
-    store.setValue(entityArg);
-  });
-  return useContextualItem(contextStore, statuses, () => {
-    if (entityRootEnabled && isFunction) {
+  useEntityRootExec(statuses, () => {
+    const isFunction = typeof entityArg === 'function';
+    if (isFunction) {
       onRunInitializer();
+      return;
+    }
+    if (isInitializing) {
+      store.initValue(entityArg);
+      return;
     }
-    return store;
-  }, deps);
+    store.setValue(entityArg);
+  }, [initialEntityKey]);
+  return store;
 };

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

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

package/es/hooks/useThrottleUpdate/index.js

@@ -0,0 +1,31 @@
+import { useMemoizedFn, useUpdate } from 'ahooks';
+import { useRef } from 'react';
+export const useThrottleUpdate = () => {
+  const update = useUpdate();
+  const prevUpdateKeyRef = useRef(-1);
+  const prevUpdateTimeRef = useRef(0);
+  const triggerUpdate = () => {
+    prevUpdateTimeRef.current = Date.now();
+    update();
+  };
+  return useMemoizedFn(function () {
+    let wait = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    if (wait === 0) {
+      triggerUpdate();
+      return;
+    }
+    const prevUpdateKey = prevUpdateKeyRef.current;
+    const prevUpdateTime = prevUpdateTimeRef.current;
+    const time = Date.now();
+    const delay = wait - (time - prevUpdateTime);
+    clearTimeout(prevUpdateKey);
+    if (delay <= 0) {
+      triggerUpdate();
+      return;
+    }
+    const key = setTimeout(() => {
+      triggerUpdate();
+    }, delay);
+    prevUpdateKeyRef.current = key;
+  });
+};

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

@@ -0,0 +1,3 @@
+export interface ThrottleUpdator {
+    (wait?: number): void;
+}

package/es/hooks/useThrottleUpdate/types.js

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

package/es/hooks/useUseCase/index.js

@@ -1,47 +1,38 @@
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import { useArgumentTypes } from '../useArgumentTypes';
-import { useConstantFn } from '../useConstantFn';
 import { useContext } from '../useContext';
 import { useContextValue } from '../useContextValue';
 import { useEntity } from '../useEntity';
 import { useFullArguments } from '../useFullArguments';
 import { useIsRenderingRef } from '../useIsRenderingRef';
-import { useOptions } from '../useOptions';
-import { useOptionsSet } from '../useOptionsSet';
 import { useProvider } from '../useProvider';
 import { useReducers } from '../useReducers';
+import { useReturn } from '../useReturn';
 import { useStatuses } from '../useStatuses';
 import { useStore } from '../useStore';
-import { useCreation } from 'ahooks';
 import { Statuses } from '../../enums/Statuses';
 import { cacheCalls } from '../../methods/cacheCalls';
 export const useUseCase = function () {
-  const isRenderingRef = useIsRenderingRef();
   for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
     args[_key] = arguments[_key];
   }
-  const argumentTypes = useArgumentTypes(args);
-  const fullArguments = useFullArguments(args, argumentTypes);
-  const _fullArguments = _slicedToArray(fullArguments, 4),
+  const arg2 = args[1];
+  const isEntityRoot = typeof arg2 === 'function';
+  const fullArguments = useFullArguments(args, isEntityRoot);
+  const _fullArguments = _slicedToArray(fullArguments, 3),
     unsafeEntity = _fullArguments[0],
-    unsafeUsecase = _fullArguments[1],
-    options = _fullArguments[2],
-    deps = _fullArguments[3];
-  const usecase = useConstantFn(unsafeUsecase);
-  const context = useContext(usecase, argumentTypes);
-  const entityContext = context;
-  const statuses = useStatuses(context, argumentTypes);
-  const store = useStore(unsafeEntity, entityContext, statuses, deps);
-  const optionsSet = useOptionsSet(entityContext, statuses);
-  const _useOptions = useOptions(options, optionsSet, statuses, deps),
-    hookOptions = _useOptions.hookOptions,
-    usecaseOptions = _useOptions.usecaseOptions;
-  const reducers = useReducers(usecase, store, context, statuses, usecaseOptions, deps);
-  const entity = useEntity(store, statuses, hookOptions);
-  const contextValue = useContextValue(store, reducers, optionsSet, statuses);
+    usecase = _fullArguments[1],
+    options = _fullArguments[2];
+  const context = useContext(usecase, isEntityRoot);
+  const statuses = useStatuses(fullArguments, context, isEntityRoot);
+  const store = useStore(unsafeEntity, context, statuses);
+  const reducers = useReducers(usecase, store, context, statuses, options);
+  const entity = useEntity(store, reducers, statuses, options);
+  const contextValue = useContextValue(entity, store, reducers, statuses);
   const Provider = useProvider(context, contextValue);
-  return useCreation(() => {
-    if ((statuses & Statuses.EntityEnabled) !== Statuses.EntityEnabled) {
+  const isRenderingRef = useIsRenderingRef();
+  return useReturn(() => {
+    const hasEntity = (statuses & Statuses.Entity) === Statuses.Entity;
+    if (!hasEntity) {
       return reducers;
     }
     const cachedReducers = cacheCalls(reducers, {
@@ -58,5 +49,5 @@ export const useUseCase = function () {
       ...entity
     } : entity;
     return [newEntity, cachedReducers, Provider];
-  }, [statuses, entity, reducers, Provider, isRenderingRef]);
+  }, [entity, reducers, Provider, statuses]);
 };