@mic-rexjs/usecases-react 2.12.0 → 2.12.1

package/es/hooks/useEntity/index.js

@@ -1,3 +1,4 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { useConstantEntityReducers } from '../useConstantEntityReducers';
 import { useContextualItem } from '../useContextualItem';
 import { useRuntimeEntity } from '../useRuntimeEntity';
@@ -8,66 +9,69 @@ import { Statuses } from '../../enums/Statuses';
 import { triggerWatchers } from '../../methods/triggerWatchers';
 import { valueUseCase } from '../../usecases/valueUseCase';
 export const useEntity = (statuses, entityArg, contextStore, options, deps) => {
-    const update = useUpdate();
-    const storeRef = useRef(null);
-    const optionsRef = useLatest(options);
-    const contextEntity = (contextStore ? contextStore.value : null);
-    const entityEnabled = (statuses & Statuses.EntityEnabled) === Statuses.EntityEnabled;
-    const entityRootEnabled = (statuses & Statuses.EntityRootEnabled) === Statuses.EntityRootEnabled;
-    const { recordValueDiff } = useConstantEntityReducers(deps, (valueUseCase));
-    const store = useContextualItem(contextStore, statuses, () => {
-        let newStore;
-        if (entityRootEnabled) {
-            const isFunction = typeof entityArg === 'function';
-            const { current } = storeRef;
-            const { value } = current || {};
-            const [, depsDiff] = recordValueDiff(deps);
-            const initailEntity = isFunction
-                ? entityArg(value, depsDiff)
-                : entityArg;
-            newStore = new EntityStore(initailEntity);
-        }
-        else {
-            newStore = new EntityStore(null);
-        }
-        storeRef.current = newStore;
-        return newStore;
-    }, deps);
-    const runtimeEntity = useRuntimeEntity(store, entityArg, contextEntity, statuses);
-    const onEntityChange = useMemoizedFn((newEntity, oldEntity) => {
-        const { onChange, watch } = optionsRef.current;
-        if (watch) {
-            triggerWatchers(watch, newEntity, oldEntity);
-        }
-        onChange?.(newEntity, oldEntity);
-        if (!entityRootEnabled) {
-            return;
-        }
-        update();
-    });
+  const update = useUpdate();
+  const storeRef = useRef(null);
+  const optionsRef = useLatest(options);
+  const contextEntity = contextStore ? contextStore.value : null;
+  const entityEnabled = (statuses & Statuses.EntityEnabled) === Statuses.EntityEnabled;
+  const entityRootEnabled = (statuses & Statuses.EntityRootEnabled) === Statuses.EntityRootEnabled;
+  const _useConstantEntityRed = useConstantEntityReducers(deps, valueUseCase),
+    recordValueDiff = _useConstantEntityRed.recordValueDiff;
+  const store = useContextualItem(contextStore, statuses, () => {
+    let newStore;
     if (entityRootEnabled) {
-        // 执行同步操作
-        store.setValue(runtimeEntity, true);
+      const isFunction = typeof entityArg === 'function';
+      const current = storeRef.current;
+      const _ref = current || {},
+        value = _ref.value;
+      const _recordValueDiff = recordValueDiff(deps),
+        _recordValueDiff2 = _slicedToArray(_recordValueDiff, 2),
+        depsDiff = _recordValueDiff2[1];
+      const initailEntity = isFunction ? entityArg(value, depsDiff) : entityArg;
+      newStore = new EntityStore(initailEntity);
+    } else {
+      newStore = new EntityStore(null);
     }
-    /**
-     * 需要马上 `watch`，因为 `useEffect` 在子组件内优先执行，
-     * 如果使用了 `setEntity` 则无法监控到变化
-     */
-    useCreation(() => {
-        if (!entityEnabled) {
-            return;
-        }
-        store.watch(onEntityChange);
-    }, [entityEnabled, store, onEntityChange]);
-    /**
-     * 在变化时候，组件更新前，使用 `unwatch`
-     */
-    useEffect(() => {
-        return () => {
-            store.unwatch(onEntityChange);
-        };
-    }, [entityEnabled, store, onEntityChange]);
-    return useCreation(() => {
-        return [runtimeEntity, store];
-    }, [runtimeEntity, store]);
-};
+    storeRef.current = newStore;
+    return newStore;
+  }, deps);
+  const runtimeEntity = useRuntimeEntity(store, entityArg, contextEntity, statuses);
+  const onEntityChange = useMemoizedFn((newEntity, oldEntity) => {
+    const _optionsRef$current = optionsRef.current,
+      onChange = _optionsRef$current.onChange,
+      watch = _optionsRef$current.watch;
+    if (watch) {
+      triggerWatchers(watch, newEntity, oldEntity);
+    }
+    onChange === null || onChange === void 0 || onChange(newEntity, oldEntity);
+    if (!entityRootEnabled) {
+      return;
+    }
+    update();
+  });
+  if (entityRootEnabled) {
+    // 执行同步操作
+    store.setValue(runtimeEntity, true);
+  }
+  /**
+   * 需要马上 `watch`，因为 `useEffect` 在子组件内优先执行，
+   * 如果使用了 `setEntity` 则无法监控到变化
+   */
+  useCreation(() => {
+    if (!entityEnabled) {
+      return;
+    }
+    store.watch(onEntityChange);
+  }, [entityEnabled, store, onEntityChange]);
+  /**
+   * 在变化时候，组件更新前，使用 `unwatch`
+   */
+  useEffect(() => {
+    return () => {
+      store.unwatch(onEntityChange);
+    };
+  }, [entityEnabled, store, onEntityChange]);
+  return useCreation(() => {
+    return [runtimeEntity, store];
+  }, [runtimeEntity, store]);
+};

package/es/hooks/useFullArguments/index.js

@@ -1,19 +1,14 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { ArgumentTypes } from '../../enums/ArgumentTypes';
 export const useFullArguments = (args, argumentTypes) => {
-    const [arg1, arg2, arg3, arg4] = args;
-    const withoutEntity = (argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity;
-    if (withoutEntity) {
-        return [
-            null,
-            arg1,
-            (arg2 || {}),
-            (arg3 || []),
-        ];
-    }
-    return [
-        arg1,
-        arg2,
-        (arg3 || {}),
-        (arg4 || []),
-    ];
-};
+  const _args = _slicedToArray(args, 4),
+    arg1 = _args[0],
+    arg2 = _args[1],
+    arg3 = _args[2],
+    arg4 = _args[3];
+  const withoutEntity = (argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity;
+  if (withoutEntity) {
+    return [null, arg1, arg2 || {}, arg3 || []];
+  }
+  return [arg1, arg2, arg3 || {}, arg4 || []];
+};

package/es/hooks/useFullArguments/types.js

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

package/es/hooks/useIsRenderingRef/index.js

@@ -1,9 +1,9 @@
 import { useLatest } from 'ahooks';
 import { useEffect } from 'react';
 export const useIsRenderingRef = () => {
-    const ref = useLatest(true);
-    useEffect(() => {
-        ref.current = false;
-    });
-    return ref;
-};
+  const ref = useLatest(true);
+  useEffect(() => {
+    ref.current = false;
+  });
+  return ref;
+};

package/es/hooks/useProvider/index.js

@@ -3,18 +3,24 @@ import { useCreation, useLatest } from 'ahooks';
 import React from 'react';
 import { contextUseCase } from '../../usecases/contextUseCase';
 export const useProvider = (statuses, context, store, reducers) => {
-    const { value: entity } = store;
-    const contextValue = useCreation(() => {
-        const { createContextValue } = contextUseCase();
-        void entity;
-        return createContextValue(store, reducers, statuses);
-    }, [statuses, entity, store, reducers]);
-    const contextValueRef = useLatest(contextValue);
-    return useConstantFn(({ children, with: withProviders = [] }) => {
-        const { Provider: ContextProvider } = context;
-        const { current: value } = contextValueRef;
-        return React.createElement(ContextProvider, { value }, withProviders.reduceRight((currentChildren, withProvider) => {
-            return React.createElement(withProvider, {}, currentChildren);
-        }, children));
-    });
-};
+  const entity = store.value;
+  const contextValue = useCreation(() => {
+    const _contextUseCase = contextUseCase(),
+      createContextValue = _contextUseCase.createContextValue;
+    void entity;
+    return createContextValue(store, reducers, statuses);
+  }, [statuses, entity, store, reducers]);
+  const contextValueRef = useLatest(contextValue);
+  return useConstantFn(_ref => {
+    let children = _ref.children,
+      _ref$with = _ref.with,
+      withProviders = _ref$with === void 0 ? [] : _ref$with;
+    const ContextProvider = context.Provider;
+    const value = contextValueRef.current;
+    return React.createElement(ContextProvider, {
+      value
+    }, withProviders.reduceRight((currentChildren, withProvider) => {
+      return React.createElement(withProvider, {}, currentChildren);
+    }, children));
+  });
+};

package/es/hooks/useProvider/types.js

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

package/es/hooks/useRuntimeEntity/index.js

@@ -2,19 +2,21 @@ import { useConstantEntityReducers } from '../useConstantEntityReducers';
 import { Statuses } from '../../enums/Statuses';
 import { valueUseCase } from '../../usecases/valueUseCase';
 export const useRuntimeEntity = (store, entityArg, contextEntity, statuses) => {
-    const { isValueChanged, recordValue } = useConstantEntityReducers(entityArg, (valueUseCase));
-    const changed = isValueChanged(entityArg);
-    const entityRootDisabled = (statuses & Statuses.EntityRootEnabled) !== Statuses.EntityRootEnabled;
-    if (entityRootDisabled) {
-        return contextEntity;
-    }
-    const isFunction = typeof entityArg === 'function';
-    const { value } = store;
-    switch (true) {
-        case isFunction:
-        case !changed:
-            return value;
-    }
-    recordValue(entityArg);
-    return entityArg;
-};
+  const _useConstantEntityRed = useConstantEntityReducers(entityArg, valueUseCase),
+    isValueChanged = _useConstantEntityRed.isValueChanged,
+    recordValue = _useConstantEntityRed.recordValue;
+  const changed = isValueChanged(entityArg);
+  const entityRootDisabled = (statuses & Statuses.EntityRootEnabled) !== Statuses.EntityRootEnabled;
+  if (entityRootDisabled) {
+    return contextEntity;
+  }
+  const isFunction = typeof entityArg === 'function';
+  const value = store.value;
+  switch (true) {
+    case isFunction:
+    case !changed:
+      return value;
+  }
+  recordValue(entityArg);
+  return entityArg;
+};

package/es/hooks/useStatuses/index.js

@@ -2,22 +2,22 @@ import { useCreation } from 'ahooks';
 import { ArgumentTypes } from '../../enums/ArgumentTypes';
 import { Statuses } from '../../enums/Statuses';
 export const useStatuses = (argumentTypes, contextValue) => {
-    return useCreation(() => {
-        let statuses = Statuses.None;
-        const { store } = (contextValue || {});
-        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]);
-};
+  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]);
+};

package/es/hooks/useUseCase/index.js

@@ -1,3 +1,6 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+const _excluded = ["watch", "onChange", "options"];
 import { useArgumentTypes } from '../useArgumentTypes';
 import { useConstantFn } from '../useConstantFn';
 import { useConstantReducers } from '../useConstantReducers';
@@ -13,56 +16,78 @@ import { useCreation, useLatest } from 'ahooks';
 import { useContext as useContextValue } from 'react';
 import { Statuses } from '../../enums/Statuses';
 import { methodUseCase } from '../../usecases/methodUseCase';
-export const useUseCase = ((...args) => {
-    const isRenderingRef = useIsRenderingRef();
-    const argumentTypes = useArgumentTypes(args);
-    const fullArguments = useFullArguments(args, argumentTypes);
-    const [unsafeEntity, unsafeUsecase, options, deps] = fullArguments;
-    const unkownUsecase = useConstantFn(unsafeUsecase);
-    const usecase = unkownUsecase;
-    const entityUseCase = unkownUsecase;
-    const context = useContext(unkownUsecase, argumentTypes);
-    const contextValue = useContextValue(context);
-    const entityContextValue = contextValue;
-    const statuses = useStatuses(argumentTypes, contextValue);
-    const optionsRef = useLatest(options);
-    const { reducers: contextReducers = null } = contextValue || {};
-    const { store: contextStore = null } = entityContextValue || {};
-    const [entity, store] = useEntity(statuses, unsafeEntity, contextStore, options, deps);
-    const { cacheCalls, captureCalls } = useConstantReducers(methodUseCase);
-    const reducers = useContextualItem(contextReducers, statuses, () => {
-        const opts = captureCalls(options, (key, callArgs) => {
-            return optionsRef.current[key]?.(...callArgs);
-        });
-        if ((statuses & Statuses.EntityEnabled) !== Statuses.EntityEnabled) {
-            return usecase(opts);
-        }
-        const hookOptions = opts;
-        const { watch, onChange, options: usecaseOptions, ...restUseCaseOptions } = hookOptions;
-        return createEntityReducers(store, entityUseCase, {
-            ...restUseCaseOptions,
-            ...usecaseOptions,
-            onGenerate(newEntity, result) {
-                return result;
-            },
-        });
-    }, deps);
-    const Provider = useProvider(statuses, context, store, reducers);
-    return useCreation(() => {
-        if ((statuses & Statuses.EntityEnabled) !== Statuses.EntityEnabled) {
-            return reducers;
-        }
-        const cachedReducers = cacheCalls(reducers, {
-            onShouldCache() {
-                return isRenderingRef.current;
-            },
-        });
-        const isNull = entity === null;
-        const isArray = Array.isArray(entity);
-        const isObjectType = typeof entity === 'object';
-        const isObjectEntity = isObjectType && !isNull && !isArray;
-        // 这里是为了让访问器 `getter` 的值保持唯一性，否则每次 `getter` 返回的对象都是新对象，无法用于 `deps`
-        const newEntity = isObjectEntity ? { ...entity } : entity;
-        return [newEntity, cachedReducers, Provider];
-    }, [statuses, entity, reducers, Provider, isRenderingRef, 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),
+    unsafeEntity = _fullArguments[0],
+    unsafeUsecase = _fullArguments[1],
+    options = _fullArguments[2],
+    deps = _fullArguments[3];
+  const unkownUsecase = useConstantFn(unsafeUsecase);
+  const usecase = unkownUsecase;
+  const entityUseCase = unkownUsecase;
+  const context = useContext(unkownUsecase, argumentTypes);
+  const contextValue = useContextValue(context);
+  const entityContextValue = contextValue;
+  const statuses = useStatuses(argumentTypes, contextValue);
+  const optionsRef = useLatest(options);
+  const _ref = contextValue || {},
+    _ref$reducers = _ref.reducers,
+    contextReducers = _ref$reducers === void 0 ? null : _ref$reducers;
+  const _ref2 = entityContextValue || {},
+    _ref2$store = _ref2.store,
+    contextStore = _ref2$store === void 0 ? null : _ref2$store;
+  const _useEntity = useEntity(statuses, unsafeEntity, contextStore, options, deps),
+    _useEntity2 = _slicedToArray(_useEntity, 2),
+    entity = _useEntity2[0],
+    store = _useEntity2[1];
+  const _useConstantReducers = useConstantReducers(methodUseCase),
+    cacheCalls = _useConstantReducers.cacheCalls,
+    captureCalls = _useConstantReducers.captureCalls;
+  const reducers = useContextualItem(contextReducers, statuses, () => {
+    const opts = captureCalls(options, (key, callArgs) => {
+      var _optionsRef$current$k, _optionsRef$current;
+      return (_optionsRef$current$k = (_optionsRef$current = optionsRef.current)[key]) === null || _optionsRef$current$k === void 0 ? void 0 : _optionsRef$current$k.call(_optionsRef$current, ...callArgs);
+    });
+    if ((statuses & Statuses.EntityEnabled) !== Statuses.EntityEnabled) {
+      return usecase(opts);
+    }
+    const hookOptions = opts;
+    const watch = hookOptions.watch,
+      onChange = hookOptions.onChange,
+      usecaseOptions = hookOptions.options,
+      restUseCaseOptions = _objectWithoutProperties(hookOptions, _excluded);
+    return createEntityReducers(store, entityUseCase, {
+      ...restUseCaseOptions,
+      ...usecaseOptions,
+      onGenerate(newEntity, result) {
+        return result;
+      }
+    });
+  }, deps);
+  const Provider = useProvider(statuses, context, store, reducers);
+  return useCreation(() => {
+    if ((statuses & Statuses.EntityEnabled) !== Statuses.EntityEnabled) {
+      return reducers;
+    }
+    const cachedReducers = cacheCalls(reducers, {
+      onShouldCache() {
+        return isRenderingRef.current;
+      }
+    });
+    const isNull = entity === null;
+    const isArray = Array.isArray(entity);
+    const isObjectType = typeof entity === 'object';
+    const isObjectEntity = isObjectType && !isNull && !isArray;
+    // 这里是为了让访问器 `getter` 的值保持唯一性，否则每次 `getter` 返回的对象都是新对象，无法用于 `deps`
+    const newEntity = isObjectEntity ? {
+      ...entity
+    } : entity;
+    return [newEntity, cachedReducers, Provider];
+  }, [statuses, entity, reducers, Provider, isRenderingRef, cacheCalls]);
+};