@mic-rexjs/usecases-react 1.3.32

package/es/hooks/useUseCase/methods/triggerWatchers/index.js

@@ -0,0 +1,10 @@
+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);
+    }
+};

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

@@ -0,0 +1,25 @@
+import { EntityReducers, EntityUseCase, Reducers, UseCase } from '@mic-rexjs/usecases';
+import { UseCaseContext, UseCaseContextWithProvider } from '../../configs/usecaseContextMap/types';
+export interface EntityGetter<T> {
+    (): T;
+}
+export interface EntityWatcher<T> {
+    (newEntity: T, prevEntity: T): void;
+}
+export type EntityWatchMap<T> = T extends unknown[] ? Record<number, EntityWatcher<T>> : T extends object ? {
+    [K in keyof T]?: EntityWatcher<T>;
+} : object;
+export interface UseCaseHookContextualOptions<T> {
+    watch?: EntityWatchMap<T>;
+    onChange?(newEntity: T, prevEntity: T): void;
+}
+export interface UseCaseHookOwnOptions<T, TOptions extends object> extends UseCaseHookContextualOptions<T> {
+    stateless?: boolean;
+    options?: TOptions;
+}
+export type UseCaseHookOptions<T, TOptions extends object> = TOptions & UseCaseHookOwnOptions<T, TOptions>;
+export interface UseCaseHook {
+    <T, TReducers extends EntityReducers<T>, TOptions extends UseCaseHookContextualOptions<T> = UseCaseHookContextualOptions<T>>(usecase: EntityUseCase<T, TReducers & EntityReducers<T>>, options?: TOptions): UseCaseContext<T, TReducers>;
+    <T, TReducers extends EntityReducers<T>, TUseCaseOptions extends object = object, TOptions extends UseCaseHookOptions<T, TUseCaseOptions> = UseCaseHookOptions<T, TUseCaseOptions>>(defaultEntity: T | EntityGetter<T>, usecase: EntityUseCase<T, TReducers, TUseCaseOptions> & UseCase<TReducers, TUseCaseOptions>, options?: TOptions, deps?: unknown[]): UseCaseContextWithProvider<T, TReducers>;
+    <T extends Reducers, TOptions extends object = object>(usecase: UseCase<T, TOptions>, options?: TOptions, deps?: unknown[]): T;
+}

package/es/hooks/useUseCase/types.js

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

package/es/index.d.ts

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

package/es/index.js

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

package/lib/components/UseCaseFragment/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UseCaseFragment = void 0;
+var _jsxRuntime = require("react/jsx-runtime");
+var _react = require("react");
+var _useUseCase = require("../../hooks/useUseCase");
+var UseCaseFragment = function UseCaseFragment(_ref) {
+  var usecase = _ref.usecase,
+    watch = _ref.watch,
+    onChange = _ref.onChange;
+  void (0, _useUseCase.useUseCase)(usecase, {
+    watch: watch,
+    onChange: onChange
+  });
+  return (0, _jsxRuntime.jsx)(_react.Fragment, {});
+};
+exports.UseCaseFragment = UseCaseFragment;

package/lib/components/UseCaseFragment/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/configs/defaultUseCaseContext/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultUseCaseContext = void 0;
+var _react = require("react");
+var defaultUseCaseContext = (0, _react.createContext)(null);
+exports.defaultUseCaseContext = defaultUseCaseContext;

package/lib/configs/usecaseContextMap/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usecaseContextMap = void 0;
+var usecaseContextMap = new Map();
+exports.usecaseContextMap = usecaseContextMap;

package/lib/configs/usecaseContextMap/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/core/usecases/optionsGetterCellectionUseCase/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.optionsGetterCollectionUseCase = void 0;
+var optionsGetterCollectionUseCase = function optionsGetterCollectionUseCase(collection) {
+  var addOptionsGetter = function addOptionsGetter(getter) {
+    collection.unshift(getter);
+  };
+  var removeOptionsGetter = function removeOptionsGetter(getter) {
+    var index = collection.indexOf(getter);
+    if (index === -1) {
+      return;
+    }
+    collection.splice(index, 1);
+  };
+  return {
+    addOptionsGetter: addOptionsGetter,
+    removeOptionsGetter: removeOptionsGetter
+  };
+};
+exports.optionsGetterCollectionUseCase = optionsGetterCollectionUseCase;

package/lib/core/usecases/optionsGetterCellectionUseCase/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/hooks/useOptionsTransfer/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOptionsTransfer = void 0;
+var _ahooks = require("ahooks");
+var useOptionsTransfer = function useOptionsTransfer(options, optionsGetterListReducers) {
+  var addOptionsGetter = optionsGetterListReducers.addOptionsGetter,
+    removeOptionsGetter = optionsGetterListReducers.removeOptionsGetter;
+  var prevRemoveOptionsGetter = (0, _ahooks.usePrevious)(removeOptionsGetter);
+  var getOptions = (0, _ahooks.useMemoizedFn)(function () {
+    return options;
+  });
+  (0, _ahooks.useCreation)(function () {
+    prevRemoveOptionsGetter === null || prevRemoveOptionsGetter === void 0 ? void 0 : prevRemoveOptionsGetter(getOptions);
+    addOptionsGetter(getOptions);
+  }, [addOptionsGetter, prevRemoveOptionsGetter, getOptions]);
+  (0, _ahooks.useUnmount)(function () {
+    removeOptionsGetter(getOptions);
+  });
+};
+exports.useOptionsTransfer = useOptionsTransfer;

package/lib/hooks/useUseCase/index.js

@@ -0,0 +1,135 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useUseCase = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _ahooks = require("ahooks");
+var _react = _interopRequireWildcard(require("react"));
+var _defaultUseCaseContext = require("../../configs/defaultUseCaseContext");
+var _usecaseContextMap = require("../../configs/usecaseContextMap");
+var _optionsGetterCellectionUseCase = require("../../core/usecases/optionsGetterCellectionUseCase");
+var _triggerCallbacks = require("./methods/triggerCallbacks");
+var _useOptionsTransfer = require("../useOptionsTransfer");
+var _usecases = require("@mic-rexjs/usecases");
+var _excluded = ["stateless", "watch", "onChange", "options"];
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var useUseCase = function useUseCase(arg1, arg2, arg3, arg4) {
+  var _useState = (0, _react.useState)(typeof arg2 === 'function'),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 1),
+    hasDefaultEntity = _useState2[0];
+  var _useState3 = (0, _react.useState)(hasDefaultEntity ? arg1 : null),
+    _useState4 = (0, _slicedToArray2["default"])(_useState3, 2),
+    entityState = _useState4[0],
+    setEntityState = _useState4[1];
+  var options = (hasDefaultEntity ? arg3 : arg2) || {};
+  var stateless = options.stateless,
+    watch = options.watch,
+    onChange = options.onChange,
+    usecaseOptions = options.options,
+    restUseCaseOptions = (0, _objectWithoutProperties2["default"])(options, _excluded);
+  var optionsGetterListRef = (0, _react.useRef)([]);
+  var deps = (hasDefaultEntity ? arg4 : arg3) || [];
+  var _useState5 = (0, _react.useState)(function () {
+      return hasDefaultEntity ? arg2 : arg1;
+    }),
+    _useState6 = (0, _slicedToArray2["default"])(_useState5, 1),
+    usecase = _useState6[0];
+  var _useState7 = (0, _react.useState)(function () {
+      var map = _usecaseContextMap.usecaseContextMap;
+      var entityUseCase = usecase;
+      if (map.has(entityUseCase)) {
+        return map.get(entityUseCase);
+      }
+      if (!hasDefaultEntity) {
+        return _defaultUseCaseContext.defaultUseCaseContext;
+      }
+      var ctx = (0, _react.createContext)(null);
+      map.set(entityUseCase, ctx);
+      return ctx;
+    }),
+    _useState8 = (0, _slicedToArray2["default"])(_useState7, 1),
+    context = _useState8[0];
+  var _ref = (0, _react.useContext)(context) || [],
+    _ref2 = (0, _slicedToArray2["default"])(_ref, 3),
+    contextEntity = _ref2[0],
+    contextEntityReducers = _ref2[1],
+    contextCollectionReducers = _ref2[2];
+  var entity = (0, _react.useMemo)(function () {
+    if (!hasDefaultEntity) {
+      return contextEntity;
+    }
+    if (!stateless) {
+      return entityState;
+    }
+    if (typeof arg1 !== 'function') {
+      return arg1;
+    }
+    return arg1();
+  }, [hasDefaultEntity, contextEntity, stateless, entityState, arg1]);
+  var initReducers = (0, _ahooks.useMemoizedFn)(function () {
+    var mergedOptions = _objectSpread(_objectSpread({}, restUseCaseOptions), usecaseOptions);
+    if (!hasDefaultEntity) {
+      return contextEntityReducers || usecase(mergedOptions);
+    }
+    var _entityReducerUseCase = (0, _usecases.entityReducerUseCase)(),
+      createEntityReducers = _entityReducerUseCase.createEntityReducers;
+    return createEntityReducers(entity, usecase, _objectSpread(_objectSpread({}, mergedOptions), {}, {
+      onChange: function onChange(newEntity, prevEntity) {
+        if (hasDefaultEntity && !stateless) {
+          setEntityState(newEntity);
+        }
+        (0, _triggerCallbacks.triggerCallbacks)(optionsGetterListRef.current, newEntity, prevEntity);
+      },
+      onGenerate: function onGenerate(newEntity, result) {
+        return result;
+      }
+    }));
+  });
+  var reducers = _react.useMemo.call(null, initReducers, [entity, initReducers].concat((0, _toConsumableArray2["default"])(deps)));
+  var collectionReducers = (0, _react.useMemo)(function () {
+    if (!hasDefaultEntity && contextCollectionReducers) {
+      return contextCollectionReducers;
+    }
+    return (0, _optionsGetterCellectionUseCase.optionsGetterCollectionUseCase)(optionsGetterListRef.current);
+  }, [hasDefaultEntity, contextCollectionReducers]);
+  var contextValueWithCollectionReducers = (0, _react.useMemo)(function () {
+    return [entity, reducers, collectionReducers];
+  }, [entity, reducers, collectionReducers]);
+  var contextValueWithCollectionReducersRef = (0, _ahooks.useLatest)(contextValueWithCollectionReducers);
+  var _useState9 = (0, _react.useState)(function () {
+      return function (_ref3) {
+        var children = _ref3.children;
+        var ContextProvider = context.Provider;
+        return _react["default"].createElement(ContextProvider, {
+          value: contextValueWithCollectionReducersRef.current
+        }, children);
+      };
+    }),
+    _useState10 = (0, _slicedToArray2["default"])(_useState9, 1),
+    Provider = _useState10[0];
+  var contextValue = (0, _react.useMemo)(function () {
+    if (hasDefaultEntity) {
+      return [entity, reducers, Provider];
+    }
+    return [entity, reducers];
+  }, [entity, reducers, hasDefaultEntity, Provider]);
+  var result = (0, _react.useMemo)(function () {
+    if (context === _defaultUseCaseContext.defaultUseCaseContext) {
+      return reducers;
+    }
+    return contextValue;
+  }, [context, reducers, contextValue]);
+  void (0, _useOptionsTransfer.useOptionsTransfer)(options, collectionReducers);
+  return result;
+};
+exports.useUseCase = useUseCase;