reshow-flux/build/cjs/ImmutableStore.js

The smallest react flux and Fast hook alternative

"use strict";

var _interopRequireDefault = require("reshow-runtime/helpers/interopRequireDefault");
exports.__esModule = true;
exports.StateMap = void 0;
exports["default"] = ImmutableStore;
exports.mergeMap = void 0;
var _objectSpread2 = _interopRequireDefault(require("reshow-runtime/helpers/objectSpread2"));
var _createClass2 = _interopRequireDefault(require("reshow-runtime/helpers/createClass"));
var _classCallCheck2 = _interopRequireDefault(require("reshow-runtime/helpers/classCallCheck"));
var _defineProperty2 = _interopRequireDefault(require("reshow-runtime/helpers/defineProperty"));
var _getObjectValue = require("get-object-value");
var _immutable = require("immutable");
exports.Map = _immutable.Map;
exports.Set = _immutable.Set;
exports.fromJS = _immutable.fromJS;
exports.equal = _immutable.is;
var _reshowFluxBase = require("reshow-flux-base");
var _callFunc = _interopRequireDefault(require("call-func"));
var _toJS = _interopRequireDefault(require("./toJS.js"));
var _reshowConstant = require("reshow-constant");
// @ts-check
/**
 * @typedef {number|string} MapKeyType
 */
/**
 * @template StateType
 * @template ActionType
 *
 * @typedef {import("reshow-flux-base").StoreObject<StateType, ActionType>} StoreObject
 */
/**
 * @typedef {import("reshow-flux-base").ActionObject} ActionObject
 */
/**
 * Hack for defined this inside MaybeMapType will make null and undefined disapper
 * @typedef {{[key: MapKeyType]:any}} MaybeMapObject
 */
/**
 * @typedef {string|undefined|null|StateMap|MaybeMapObject} MaybeMapType
 */
/**
 * @typedef {ActionObject|MaybeMapType} ImmutableAction
 */
/**
 * @interface
 */
var StateMap = exports.StateMap = /*#__PURE__*/(0, _createClass2["default"])(function StateMap() {
  (0, _classCallCheck2["default"])(this, StateMap);
  /** @type {function(MapKeyType[]):any}*/
  (0, _defineProperty2["default"])(this, "getIn", void 0);
  /** @type {function(MapKeyType):any}*/
  (0, _defineProperty2["default"])(this, "get", void 0);
  /** @type {function(MapKeyType, any):any}*/
  (0, _defineProperty2["default"])(this, "set", void 0);
  /** @type {function():any}*/
  (0, _defineProperty2["default"])(this, "toJS", void 0);
  /** @type {function():any}*/
  (0, _defineProperty2["default"])(this, "clear", void 0);
});
/**
 * @typedef {object} StoreObjectWithMap
 * @property {function(MapKeyType):any} getMap
 */
/**
 * @template [StateType=StateMap]
 * @template [ActionType=MaybeMapType]
 *
 * @typedef {StoreObject<StateType, ActionType>&StoreObjectWithMap} ImmutableStoreObject
 */
/**
 * @template [StateType=StateMap]
 * @template [ActionType=MaybeMapType]
 *
 * @callback ReducerTypeWithMap
 * @param {StateType} state
 * @param {ActionType} action
 * @returns {StateType}
 */
/**
 * @callback forEachCb
 * @param {any} Value
 * @param {any} Key
 * @returns {any}
 */
/**
 * @param {any} state
 * @param {MapKeyType} k
 * @returns {object}
 */
var _getMap = function getMap(state, k) {
  if (state && state.get) {
    return (0, _toJS["default"])(state.get(k));
  } else {
    return {};
  }
};

/**
 * Why not just use immutable mergeMap?
 * Because after merge can not use === to compare
 * https://github.com/react-atomic/reshow/issues/123
 *
 * @template {StateMap} StateType
 * @param {StateType} state
 * @param {MaybeMapType} maybeMap
 * @returns {StateType}
 */
var mergeMap = exports.mergeMap = function mergeMap(state, maybeMap) {
  if (_reshowConstant.STRING === typeof maybeMap) {
    state = state.set("type", maybeMap);
  } else {
    try {
      (0, _getObjectValue.forEachMap)(maybeMap,
      /**
       * @param {any} v
       * @param {MapKeyType} k
       */
      function (v, k) {
        state = state.set(k, v);
      });
    } catch (e) {}
  }
  return state;
};

/**
 * @template {StateMap} StateType
 * @template {MaybeMapType} ActionType
 * @type ReducerTypeWithMap<StateType, ActionType>
 */
var defaultReducer = function defaultReducer(state, action) {
  return mergeMap(state, action);
};

/**
 * @template [StateType=StateMap]
 * @template [ActionType=MaybeMapType]
 *
 * @param {ReducerTypeWithMap<StateType, ActionType>?} [reducer]
 * @param {import("reshow-flux-base").InitStateType<StateType>} [initState]
 *
 * @returns {[ImmutableStoreObject<StateType, ActionType>, dispatch]}
 */
function ImmutableStore(reducer, initState) {
  var nextReducer = /**@type ReducerTypeWithMap<StateType, ActionType>*/
  reducer || defaultReducer;
  var stateMap = /**@type StateMap*/mergeMap((0, _immutable.Map)(), (0, _callFunc["default"])(initState));
  var _createReducer = (0, _reshowFluxBase.createReducer)(nextReducer, /**@type StateType*/stateMap),
    store = _createReducer[0],
    dispatch = _createReducer[1];

  /**
   * @type ImmutableStoreObject<StateType, ActionType>
   */
  var nextStore = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, store), {}, {
    getMap: function getMap(/** @type MapKeyType */k) {
      return _getMap(store.getState(), k);
    }
  });
  return [nextStore, dispatch];
}