@mic-rexjs/usecases-react 2.11.2 → 2.12.1

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

@@ -7,16 +7,19 @@ import { ContextualEntityReducers } from '../../usecases/contextUseCase/types';
 export interface NonEntitySymbolSet extends SymbolSet {
     entity?: never;
 }
-export type RootCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = [
+export type CoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = [
     entity: T,
     reducers: ContextualEntityReducers<T, TEntityReducers>,
     Provider: UseCaseProvider
 ];
-export type ContextualCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = [
-    entity: T,
-    reducers: ContextualEntityReducers<T, TEntityReducers>
-];
-export type CoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = RootCoreCollection<T, TEntityReducers> | ContextualCoreCollection<T, TEntityReducers>;
+/**
+ * @deprecated 请用 `CoreCollection` 代替
+ */
+export type RootCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = CoreCollection<T, TEntityReducers>;
+/**
+ * @deprecated 请用 `CoreCollection` 代替
+ */
+export type ContextualCoreCollection<T, TEntityReducers extends EntityReducerMap<T>> = CoreCollection<T, TEntityReducers>;
 export interface EntityGetter<T, TDependencies extends Dependencies = Dependencies> {
     (entity: T | undefined, changedDeps: TDependencies): T;
 }
@@ -51,10 +54,10 @@ export interface ReducersHook {
     <T extends ReducerMap, TUseCaseOptions extends object = object>(usecase: UseCase<T & SymbolSetTarget<NonEntitySymbolSet>, TUseCaseOptions>, options?: TUseCaseOptions, deps?: Dependencies): T;
 }
 export interface ContextualCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducerMap<T>>(usecase: InferableEntityUseCase<T, TEntityReducers>, options?: UseCaseHookContextualOptions<T>, deps?: Dependencies): ContextualCoreCollection<T, TEntityReducers>;
+    <T, TEntityReducers extends EntityReducerMap<T>>(usecase: InferableEntityUseCase<T, TEntityReducers>, options?: UseCaseHookContextualOptions<T>, deps?: Dependencies): CoreCollection<T, TEntityReducers>;
 }
 export interface RootCoreCollectionHook {
-    <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object, TDependencies extends Dependencies = Dependencies>(entity: T | EntityGetter<T, TDependencies>, usecase: InferableEntityUseCase<T, TEntityReducers & EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: TDependencies): RootCoreCollection<T, EntityReducers<T, TEntityReducers>>;
+    <T, TEntityReducers extends EntityReducerMap<T>, TUseCaseOptions extends object = object, TDependencies extends Dependencies = Dependencies>(entity: T | EntityGetter<T, TDependencies>, usecase: InferableEntityUseCase<T, TEntityReducers & EntityReducers<T>, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: TDependencies): CoreCollection<T, EntityReducers<T, TEntityReducers>>;
 }
 export interface CoreCollectionHook extends ContextualCoreCollectionHook, RootCoreCollectionHook {
 }

package/es/hooks/useUseCase/types.js

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

package/es/index.js

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

package/es/methods/triggerWatchers/index.js

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

package/es/types.js

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

package/es/usecases/contextUseCase/index.js

@@ -3,71 +3,76 @@ import { createContext } from 'react';
 import { ArgumentTypes } from '../../enums/ArgumentTypes';
 import { Statuses } from '../../enums/Statuses';
 export const contextUseCase = createUseCase(() => {
-    const referenceMap = new Map();
-    const defaultUseCaseContext = createContext(null);
-    return () => {
-        const createContextValue = (store, reducers, statuses) => {
-            if ((statuses & Statuses.EntityEnabled) === Statuses.EntityEnabled) {
-                return {
-                    store,
-                    reducers,
-                    statuses,
-                };
-            }
-            return { reducers, statuses };
-        };
-        const getUseCaseContext = (usecase) => {
-            if (!referenceMap.has(usecase)) {
-                return defaultUseCaseContext;
-            }
-            const { value } = referenceMap.get(usecase);
-            return value;
-        };
-        const registerUseCase = (usecase, argumentTypes) => {
-            if (referenceMap.has(usecase)) {
-                const reference = referenceMap.get(usecase);
-                const { value, times } = reference;
-                referenceMap.set(usecase, {
-                    value,
-                    times: times + 1,
-                });
-                return value;
-            }
-            if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
-                return defaultUseCaseContext;
-            }
-            const context = createContext(null);
-            referenceMap.set(usecase, {
-                value: context,
-                times: 1,
-            });
-            return context;
-        };
-        const unregisterUseCase = (usecase, argumentTypes) => {
-            if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
-                return false;
-            }
-            if (!referenceMap.has(usecase)) {
-                return false;
-            }
-            const reference = referenceMap.get(usecase);
-            const { value, times } = reference;
-            if (times === 1) {
-                referenceMap.delete(usecase);
-            }
-            else {
-                referenceMap.set(usecase, {
-                    value,
-                    times: times - 1,
-                });
-            }
-            return true;
-        };
+  const referenceMap = new Map();
+  const defaultUseCaseContext = createContext(null);
+  return () => {
+    const createContextValue = (store, reducers, statuses) => {
+      if ((statuses & Statuses.EntityEnabled) === Statuses.EntityEnabled) {
         return {
-            createContextValue,
-            getUseCaseContext,
-            registerUseCase,
-            unregisterUseCase,
+          store,
+          reducers,
+          statuses
         };
+      }
+      return {
+        reducers,
+        statuses
+      };
+    };
+    const getUseCaseContext = usecase => {
+      if (!referenceMap.has(usecase)) {
+        return defaultUseCaseContext;
+      }
+      const _referenceMap$get = referenceMap.get(usecase),
+        value = _referenceMap$get.value;
+      return value;
+    };
+    const registerUseCase = (usecase, argumentTypes) => {
+      if (referenceMap.has(usecase)) {
+        const reference = referenceMap.get(usecase);
+        const value = reference.value,
+          times = reference.times;
+        referenceMap.set(usecase, {
+          value,
+          times: times + 1
+        });
+        return value;
+      }
+      if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
+        return defaultUseCaseContext;
+      }
+      const context = createContext(null);
+      referenceMap.set(usecase, {
+        value: context,
+        times: 1
+      });
+      return context;
+    };
+    const unregisterUseCase = (usecase, argumentTypes) => {
+      if ((argumentTypes & ArgumentTypes.Entity) !== ArgumentTypes.Entity) {
+        return false;
+      }
+      if (!referenceMap.has(usecase)) {
+        return false;
+      }
+      const reference = referenceMap.get(usecase);
+      const value = reference.value,
+        times = reference.times;
+      if (times === 1) {
+        referenceMap.delete(usecase);
+      } else {
+        referenceMap.set(usecase, {
+          value,
+          times: times - 1
+        });
+      }
+      return true;
+    };
+    return {
+      createContextValue,
+      getUseCaseContext,
+      registerUseCase,
+      unregisterUseCase
     };
-});
+  };
+});

package/es/usecases/contextUseCase/types.js

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

package/es/usecases/methodUseCase/index.js

@@ -1,55 +1,72 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { valueUseCase } from '../valueUseCase';
 export const methodUseCase = () => {
-    const { isValueMatched } = valueUseCase();
-    const cacheCall = (factory, options) => {
-        let cache;
-        const { onShouldCache = () => {
-            return true;
-        }, onCompare = (newArgs, oldArgs) => {
-            return isValueMatched(newArgs, oldArgs);
-        }, } = options || {};
-        return ((...args) => {
-            const cacheable = onShouldCache();
-            if (cache && cacheable) {
-                const { parameters, returnValue } = cache;
-                if (onCompare(parameters, args)) {
-                    return returnValue;
-                }
-            }
-            const returnValue = factory(...args);
-            if (cacheable) {
-                cache = {
-                    parameters: args,
-                    returnValue,
-                };
-            }
-            return returnValue;
-        });
+  const _valueUseCase = valueUseCase(),
+    isValueMatched = _valueUseCase.isValueMatched;
+  const cacheCall = (factory, options) => {
+    let cache;
+    const _ref = options || {},
+      _ref$onShouldCache = _ref.onShouldCache,
+      onShouldCache = _ref$onShouldCache === void 0 ? () => {
+        return true;
+      } : _ref$onShouldCache,
+      _ref$onCompare = _ref.onCompare,
+      onCompare = _ref$onCompare === void 0 ? (newArgs, oldArgs) => {
+        return isValueMatched(newArgs, oldArgs);
+      } : _ref$onCompare;
+    return function () {
+      const cacheable = onShouldCache();
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (cache && cacheable) {
+        const _cache = cache,
+          parameters = _cache.parameters,
+          returnValue = _cache.returnValue;
+        if (onCompare(parameters, args)) {
+          return returnValue;
+        }
+      }
+      const returnValue = factory(...args);
+      if (cacheable) {
+        cache = {
+          parameters: args,
+          returnValue
+        };
+      }
+      return returnValue;
     };
-    const cacheCalls = (sourceFactories, options) => {
-        const cachedFactories = {};
-        Object.entries(sourceFactories).forEach(([key, factory]) => {
-            cachedFactories[key] = cacheCall(factory, options);
-        });
-        return cachedFactories;
-    };
-    const captureCalls = (obj, callback) => {
-        const newObj = {};
-        Object.keys(obj).forEach((key) => {
-            const value = obj[key];
-            if (typeof value === 'function') {
-                newObj[key] = ((...args) => {
-                    return callback(key, args);
-                });
-                return;
-            }
-            newObj[key] = value;
-        });
-        return newObj;
-    };
-    return {
-        cacheCall,
-        cacheCalls,
-        captureCalls,
-    };
-};
+  };
+  const cacheCalls = (sourceFactories, options) => {
+    const cachedFactories = {};
+    Object.entries(sourceFactories).forEach(_ref2 => {
+      let _ref3 = _slicedToArray(_ref2, 2),
+        key = _ref3[0],
+        factory = _ref3[1];
+      cachedFactories[key] = cacheCall(factory, options);
+    });
+    return cachedFactories;
+  };
+  const captureCalls = (obj, callback) => {
+    const newObj = {};
+    Object.keys(obj).forEach(key => {
+      const value = obj[key];
+      if (typeof value === 'function') {
+        newObj[key] = function () {
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          return callback(key, args);
+        };
+        return;
+      }
+      newObj[key] = value;
+    });
+    return newObj;
+  };
+  return {
+    cacheCall,
+    cacheCalls,
+    captureCalls
+  };
+};

package/es/usecases/methodUseCase/types.js

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