@mic-rexjs/usecases-react/lib/hooks/useStore/index.js

React-based solution for use usecases of Clean Architecture

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.useStore = void 0;
var _useContextualItem = require("../useContextualItem");
var _usecases = require("@mic-rexjs/usecases");
var _react = require("react");
var _Statuses = require("../../enums/Statuses");
var _entityRuntimeUseCase = require("../../usecases/entityRuntimeUseCase");
var _valueUseCase2 = require("../../usecases/valueUseCase");
var useStore = exports.useStore = function useStore(entityArg, context, statuses, options) {
  var deps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
  var storeRef = (0, _react.useRef)(null);
  var createEntityListRef = (0, _react.useRef)([]);
  var entityRootEnabled = (statuses & _Statuses.Statuses.EntityRootEnabled) === _Statuses.Statuses.EntityRootEnabled;
  var contextValue = (0, _react.useContext)(context);
  var _ref = contextValue || {},
    _ref$store = _ref.store,
    contextStore = _ref$store === void 0 ? null : _ref$store;
  var initStore = function initStore() {
    var isFunction = typeof entityArg === 'function';
    if (!isFunction) {
      return new _usecases.EntityStore(entityArg);
    }
    var index = 0;
    var currentStore = storeRef.current;
    var _ref2 = currentStore || {},
      currentEntity = _ref2.value;
    var prevCreateEntityList = createEntityListRef.current;
    var store = new _usecases.EntityStore(currentEntity);
    var createEntityList = [];
    var _valueUseCase = (0, _valueUseCase2.valueUseCase)(),
      isObjectValue = _valueUseCase.isObjectValue,
      matchValue = _valueUseCase.matchValue;
    var _createEntityReducers = (0, _usecases.createEntityReducers)(store, _entityRuntimeUseCase.entityRuntimeUseCase, {
        onInit: function onInit(currentValue) {
          return entityArg(currentValue);
        },
        onCreate: function onCreate(newEntity, oldEntity) {
          var currentIndex = index;
          var isObject = isObjectValue(oldEntity);
          var isArray = isObject && Array.isArray(oldEntity);
          index++;
          createEntityList[currentIndex] = newEntity;
          if (!isObject || isArray) {
            return (0, _usecases.createEntity)(oldEntity, newEntity);
          }
          var descriptors = {};
          var prevEntity = prevCreateEntityList[currentIndex];
          matchValue(prevEntity, newEntity, function (key) {
            var descriptor = Object.getOwnPropertyDescriptor(newEntity, key) || null;
            if (descriptor === null) {
              return;
            }
            descriptors[key] = descriptor;
          });
          return (0, _usecases.createEntity)(oldEntity, Object.defineProperties({}, descriptors));
        },
        onGenerate: function onGenerate(entity, result) {
          if (typeof result === 'undefined') {
            return [entity, result];
          }
          var newResult = (0, _usecases.createEntity)(entity, result);
          // 不能用 `store.value`，因为可能存在异步，异步更新是需要触发组件更新的
          store.setValue(newResult);
          return [newResult, result];
        },
        onReturn: function onReturn(result) {
          // 不能用 `store.value`，因为可能存在异步，异步更新是需要触发组件更新的
          store.setValue(result);
          return result;
        }
      }),
      initEntity = _createEntityReducers.initEntity;
    initEntity();
    storeRef.current = store;
    createEntityListRef.current = createEntityList;
    return store;
  };
  return (0, _useContextualItem.useContextualItem)(contextStore, statuses, function () {
    if (!entityRootEnabled) {
      return new _usecases.EntityStore(null);
    }
    return initStore();
  }, deps);
};