@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/reducers/index.js

@@ -0,0 +1,139 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  keplerGlReducer: true,
+  keplerGlReducerCore: true,
+  visStateLens: true,
+  mapStateLens: true,
+  uiStateLens: true,
+  mapStyleLens: true,
+  visStateReducer: true,
+  mapStateReducer: true,
+  mapStyleReducer: true,
+  visStateUpdaters: true,
+  mapStateUpdaters: true,
+  mapStyleUpdaters: true,
+  uiStateUpdaters: true,
+  combineUpdaters: true,
+  combinedUpdaters: true,
+  visStateMergers: true
+};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _root["default"];
+  }
+});
+Object.defineProperty(exports, "keplerGlReducer", {
+  enumerable: true,
+  get: function get() {
+    return _root["default"];
+  }
+});
+Object.defineProperty(exports, "keplerGlReducerCore", {
+  enumerable: true,
+  get: function get() {
+    return _core["default"];
+  }
+});
+Object.defineProperty(exports, "visStateLens", {
+  enumerable: true,
+  get: function get() {
+    return _core.visStateLens;
+  }
+});
+Object.defineProperty(exports, "mapStateLens", {
+  enumerable: true,
+  get: function get() {
+    return _core.mapStateLens;
+  }
+});
+Object.defineProperty(exports, "uiStateLens", {
+  enumerable: true,
+  get: function get() {
+    return _core.uiStateLens;
+  }
+});
+Object.defineProperty(exports, "mapStyleLens", {
+  enumerable: true,
+  get: function get() {
+    return _core.mapStyleLens;
+  }
+});
+Object.defineProperty(exports, "visStateReducer", {
+  enumerable: true,
+  get: function get() {
+    return _visState["default"];
+  }
+});
+Object.defineProperty(exports, "mapStateReducer", {
+  enumerable: true,
+  get: function get() {
+    return _mapState["default"];
+  }
+});
+Object.defineProperty(exports, "mapStyleReducer", {
+  enumerable: true,
+  get: function get() {
+    return _mapStyle["default"];
+  }
+});
+exports.visStateMergers = exports.combinedUpdaters = exports.combineUpdaters = exports.uiStateUpdaters = exports.mapStyleUpdaters = exports.mapStateUpdaters = exports.visStateUpdaters = void 0;
+
+var _root = _interopRequireDefault(require("./root"));
+
+var _core = _interopRequireWildcard(require("./core"));
+
+var _visState = _interopRequireDefault(require("./vis-state"));
+
+var _mapState = _interopRequireDefault(require("./map-state"));
+
+var _mapStyle = _interopRequireDefault(require("./map-style"));
+
+var _visStateUpdaters = _interopRequireWildcard(require("./vis-state-updaters"));
+
+exports.visStateUpdaters = _visStateUpdaters;
+
+var _mapStateUpdaters = _interopRequireWildcard(require("./map-state-updaters"));
+
+exports.mapStateUpdaters = _mapStateUpdaters;
+
+var _mapStyleUpdaters = _interopRequireWildcard(require("./map-style-updaters"));
+
+exports.mapStyleUpdaters = _mapStyleUpdaters;
+
+var _uiStateUpdaters = _interopRequireWildcard(require("./ui-state-updaters"));
+
+exports.uiStateUpdaters = _uiStateUpdaters;
+
+var _combineUpdaters = _interopRequireWildcard(require("./combined-updaters"));
+
+var _combinedUpdaters = _combineUpdaters;
+exports.combineUpdaters = _combineUpdaters;
+exports.combinedUpdaters = _combineUpdaters;
+
+var _visStateMergers = _interopRequireWildcard(require("./vis-state-merger"));
+
+exports.visStateMergers = _visStateMergers;
+
+var _composerHelpers = require("./composer-helpers");
+
+Object.keys(_composerHelpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _composerHelpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _composerHelpers[key];
+    }
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/reducers/map-state-updaters.js

@@ -0,0 +1,239 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getMapDimForSplitMap = getMapDimForSplitMap;
+exports.toggleSplitMapUpdater = exports.receiveMapConfigUpdater = exports.resetMapConfigUpdater = exports.togglePerspectiveUpdater = exports.fitBoundsUpdater = exports.updateMapUpdater = exports.INITIAL_MAP_STATE = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _projectionUtils = require("../utils/projection-utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/** @typedef {import('./map-state-updaters').MapState} MapState */
+
+/**
+ * Updaters for `mapState` reducer. Can be used in your root reducer to directly modify kepler.gl's state.
+ * Read more about [Using updaters](../advanced-usage/using-updaters.md)
+ * @public
+ * @example
+ *
+ * import keplerGlReducer, {mapStateUpdaters} from 'kepler.gl/reducers';
+ * // Root Reducer
+ * const reducers = combineReducers({
+ *  keplerGl: keplerGlReducer,
+ *  app: appReducer
+ * });
+ *
+ * const composedReducer = (state, action) => {
+ *  switch (action.type) {
+ *    // click button to close side panel
+ *    case 'CLICK_BUTTON':
+ *      return {
+ *        ...state,
+ *        keplerGl: {
+ *          ...state.keplerGl,
+ *          foo: {
+ *             ...state.keplerGl.foo,
+ *             mapState: mapStateUpdaters.fitBoundsUpdater(
+ *               mapState, {payload: [127.34, 31.09, 127.56, 31.59]]}
+ *             )
+ *          }
+ *        }
+ *      };
+ *  }
+ *  return reducers(state, action);
+ * };
+ *
+ * export default composedReducer;
+ */
+
+/* eslint-disable no-unused-vars */
+// @ts-ignore
+var mapStateUpdaters = null;
+/* eslint-enable no-unused-vars */
+
+/**
+ * Default initial `mapState`
+ * @memberof mapStateUpdaters
+ * @constant
+ * @property pitch Default: `0`
+ * @property bearing Default: `0`
+ * @property latitude Default: `37.75043`
+ * @property longitude Default: `-122.34679`
+ * @property zoom Default: `9`
+ * @property dragRotate Default: `false`
+ * @property width Default: `800`
+ * @property height Default: `800`
+ * @property isSplit Default: `false`
+ * @type {MapState}
+ * @public
+ */
+
+var INITIAL_MAP_STATE = {
+  pitch: 0,
+  bearing: 0,
+  latitude: 37.75043,
+  longitude: -122.34679,
+  zoom: 9,
+  dragRotate: false,
+  width: 800,
+  height: 800,
+  isSplit: false
+};
+/* Updaters */
+
+/**
+ * Update map viewport
+ * @memberof mapStateUpdaters
+ * @type {typeof import('./map-state-updaters').updateMapUpdater}
+ * @public
+ */
+
+exports.INITIAL_MAP_STATE = INITIAL_MAP_STATE;
+
+var updateMapUpdater = function updateMapUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), action.payload || {});
+};
+/**
+ * Fit map viewport to bounds
+ * @memberof mapStateUpdaters
+ * @type {typeof import('./map-state-updaters').fitBoundsUpdater}
+ * @public
+ */
+
+
+exports.updateMapUpdater = updateMapUpdater;
+
+var fitBoundsUpdater = function fitBoundsUpdater(state, action) {
+  var centerAndZoom = (0, _projectionUtils.getCenterAndZoomFromBounds)(action.payload, {
+    width: state.width,
+    height: state.height
+  });
+
+  if (!centerAndZoom) {
+    // bounds is invalid
+    return state;
+  }
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    latitude: centerAndZoom.center[1],
+    longitude: centerAndZoom.center[0]
+  }, Number.isFinite(centerAndZoom.zoom) ? {
+    zoom: centerAndZoom.zoom
+  } : {});
+};
+/**
+ * Toggle between 3d and 2d map.
+ * @memberof mapStateUpdaters
+ * @type {typeof import('./map-state-updaters').togglePerspectiveUpdater}
+ * @public
+ */
+
+
+exports.fitBoundsUpdater = fitBoundsUpdater;
+
+var togglePerspectiveUpdater = function togglePerspectiveUpdater(state) {
+  return _objectSpread(_objectSpread(_objectSpread({}, state), {
+    pitch: state.dragRotate ? 0 : 50,
+    bearing: state.dragRotate ? 0 : 24
+  }), {}, {
+    dragRotate: !state.dragRotate
+  });
+};
+/**
+ * reset mapState to initial State
+ * @memberof mapStateUpdaters
+ * @type {typeof import('./map-state-updaters').resetMapConfigUpdater}
+ * @public
+ */
+
+
+exports.togglePerspectiveUpdater = togglePerspectiveUpdater;
+
+var resetMapConfigUpdater = function resetMapConfigUpdater(state) {
+  return _objectSpread(_objectSpread(_objectSpread({}, INITIAL_MAP_STATE), state.initialState), {}, {
+    initialState: state.initialState
+  });
+}; // consider case where you have a split map and user wants to reset
+
+/**
+ * Update `mapState` to propagate a new config
+ * @memberof mapStateUpdaters
+ * @type {typeof import('./map-state-updaters').receiveMapConfigUpdater}
+ * @public
+ */
+
+
+exports.resetMapConfigUpdater = resetMapConfigUpdater;
+
+var receiveMapConfigUpdater = function receiveMapConfigUpdater(state, _ref) {
+  var _ref$payload = _ref.payload,
+      _ref$payload$config = _ref$payload.config,
+      config = _ref$payload$config === void 0 ? {} : _ref$payload$config,
+      _ref$payload$options = _ref$payload.options,
+      options = _ref$payload$options === void 0 ? {} : _ref$payload$options,
+      _ref$payload$bounds = _ref$payload.bounds,
+      bounds = _ref$payload$bounds === void 0 ? null : _ref$payload$bounds;
+
+  var _ref2 = config || {},
+      mapState = _ref2.mapState; // merged received mapstate with previous state
+
+
+  var mergedState = _objectSpread(_objectSpread({}, state), mapState); // if center map
+  // center map will override mapState config
+
+
+  if (options.centerMap && bounds) {
+    mergedState = fitBoundsUpdater(mergedState, {
+      payload: bounds
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, mergedState), getMapDimForSplitMap(mergedState.isSplit, state));
+};
+/**
+ * Toggle between one or split maps
+ * @memberof mapStateUpdaters
+ * @type {typeof import('./map-state-updaters').toggleSplitMapUpdater}
+ * @public
+ */
+
+
+exports.receiveMapConfigUpdater = receiveMapConfigUpdater;
+
+var toggleSplitMapUpdater = function toggleSplitMapUpdater(state) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    isSplit: !state.isSplit
+  }, getMapDimForSplitMap(!state.isSplit, state));
+}; // Helpers
+
+
+exports.toggleSplitMapUpdater = toggleSplitMapUpdater;
+
+function getMapDimForSplitMap(isSplit, state) {
+  // cases:
+  // 1. state split: true - isSplit: true
+  // do nothing
+  // 2. state split: false - isSplit: false
+  // do nothing
+  if (state.isSplit === isSplit) {
+    return {};
+  }
+
+  var width = state.isSplit && !isSplit ? // 3. state split: true - isSplit: false
+  // double width
+  state.width * 2 : // 4. state split: false - isSplit: true
+  // split width
+  state.width / 2;
+  return {
+    width: width
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/reducers/map-state-updaters.js"],"names":["mapStateUpdaters","INITIAL_MAP_STATE","pitch","bearing","latitude","longitude","zoom","dragRotate","width","height","isSplit","updateMapUpdater","state","action","payload","fitBoundsUpdater","centerAndZoom","center","Number","isFinite","togglePerspectiveUpdater","resetMapConfigUpdater","initialState","receiveMapConfigUpdater","config","options","bounds","mapState","mergedState","centerMap","getMapDimForSplitMap","toggleSplitMapUpdater"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {getCenterAndZoomFromBounds} from 'utils/projection-utils';\n\n/** @typedef {import('./map-state-updaters').MapState} MapState */\n\n/**\n * Updaters for `mapState` reducer. Can be used in your root reducer to directly modify kepler.gl's state.\n * Read more about [Using updaters](../advanced-usage/using-updaters.md)\n * @public\n * @example\n *\n * import keplerGlReducer, {mapStateUpdaters} from 'kepler.gl/reducers';\n * // Root Reducer\n * const reducers = combineReducers({\n *  keplerGl: keplerGlReducer,\n *  app: appReducer\n * });\n *\n * const composedReducer = (state, action) => {\n *  switch (action.type) {\n *    // click button to close side panel\n *    case 'CLICK_BUTTON':\n *      return {\n *        ...state,\n *        keplerGl: {\n *          ...state.keplerGl,\n *          foo: {\n *             ...state.keplerGl.foo,\n *             mapState: mapStateUpdaters.fitBoundsUpdater(\n *               mapState, {payload: [127.34, 31.09, 127.56, 31.59]]}\n *             )\n *          }\n *        }\n *      };\n *  }\n *  return reducers(state, action);\n * };\n *\n * export default composedReducer;\n */\n/* eslint-disable no-unused-vars */\n// @ts-ignore\nconst mapStateUpdaters = null;\n/* eslint-enable no-unused-vars */\n\n/**\n * Default initial `mapState`\n * @memberof mapStateUpdaters\n * @constant\n * @property pitch Default: `0`\n * @property bearing Default: `0`\n * @property latitude Default: `37.75043`\n * @property longitude Default: `-122.34679`\n * @property zoom Default: `9`\n * @property dragRotate Default: `false`\n * @property width Default: `800`\n * @property height Default: `800`\n * @property isSplit Default: `false`\n * @type {MapState}\n * @public\n */\nexport const INITIAL_MAP_STATE = {\n  pitch: 0,\n  bearing: 0,\n  latitude: 37.75043,\n  longitude: -122.34679,\n  zoom: 9,\n  dragRotate: false,\n  width: 800,\n  height: 800,\n  isSplit: false\n};\n\n/* Updaters */\n/**\n * Update map viewport\n * @memberof mapStateUpdaters\n * @type {typeof import('./map-state-updaters').updateMapUpdater}\n * @public\n */\nexport const updateMapUpdater = (state, action) => ({\n  ...state,\n  ...(action.payload || {})\n});\n\n/**\n * Fit map viewport to bounds\n * @memberof mapStateUpdaters\n * @type {typeof import('./map-state-updaters').fitBoundsUpdater}\n * @public\n */\nexport const fitBoundsUpdater = (state, action) => {\n  const centerAndZoom = getCenterAndZoomFromBounds(action.payload, {\n    width: state.width,\n    height: state.height\n  });\n  if (!centerAndZoom) {\n    // bounds is invalid\n    return state;\n  }\n\n  return {\n    ...state,\n    latitude: centerAndZoom.center[1],\n    longitude: centerAndZoom.center[0],\n    // For marginal or invalid bounds, zoom may be NaN. Make sure to provide a valid value in order\n    // to avoid corrupt state and potential crashes as zoom is expected to be a number\n    ...(Number.isFinite(centerAndZoom.zoom) ? {zoom: centerAndZoom.zoom} : {})\n  };\n};\n\n/**\n * Toggle between 3d and 2d map.\n * @memberof mapStateUpdaters\n * @type {typeof import('./map-state-updaters').togglePerspectiveUpdater}\n * @public\n */\nexport const togglePerspectiveUpdater = state => ({\n  ...state,\n  ...{\n    pitch: state.dragRotate ? 0 : 50,\n    bearing: state.dragRotate ? 0 : 24\n  },\n  dragRotate: !state.dragRotate\n});\n\n/**\n * reset mapState to initial State\n * @memberof mapStateUpdaters\n * @type {typeof import('./map-state-updaters').resetMapConfigUpdater}\n * @public\n */\nexport const resetMapConfigUpdater = state => ({\n  ...INITIAL_MAP_STATE,\n  ...state.initialState,\n  initialState: state.initialState\n});\n\n// consider case where you have a split map and user wants to reset\n/**\n * Update `mapState` to propagate a new config\n * @memberof mapStateUpdaters\n * @type {typeof import('./map-state-updaters').receiveMapConfigUpdater}\n * @public\n */\nexport const receiveMapConfigUpdater = (\n  state,\n  {payload: {config = {}, options = {}, bounds = null}}\n) => {\n  const {mapState} = config || {};\n\n  // merged received mapstate with previous state\n  let mergedState = {...state, ...mapState};\n\n  // if center map\n  // center map will override mapState config\n  if (options.centerMap && bounds) {\n    mergedState = fitBoundsUpdater(mergedState, {\n      payload: bounds\n    });\n  }\n\n  return {\n    ...mergedState,\n    // update width if `isSplit` has changed\n    ...getMapDimForSplitMap(mergedState.isSplit, state)\n  };\n};\n\n/**\n * Toggle between one or split maps\n * @memberof mapStateUpdaters\n * @type {typeof import('./map-state-updaters').toggleSplitMapUpdater}\n * @public\n */\nexport const toggleSplitMapUpdater = state => ({\n  ...state,\n  isSplit: !state.isSplit,\n  ...getMapDimForSplitMap(!state.isSplit, state)\n});\n\n// Helpers\nexport function getMapDimForSplitMap(isSplit, state) {\n  // cases:\n  // 1. state split: true - isSplit: true\n  // do nothing\n  // 2. state split: false - isSplit: false\n  // do nothing\n  if (state.isSplit === isSplit) {\n    return {};\n  }\n\n  const width =\n    state.isSplit && !isSplit\n      ? // 3. state split: true - isSplit: false\n        // double width\n        state.width * 2\n      : // 4. state split: false - isSplit: true\n        // split width\n        state.width / 2;\n\n  return {\n    width\n  };\n}\n"]}

package/dist/reducers/map-state.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.mapStateReducerFactory = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _reduxActions = require("redux-actions");
+
+var _actionTypes = _interopRequireDefault(require("../constants/action-types"));
+
+var mapStateUpdaters = _interopRequireWildcard(require("./map-state-updaters"));
+
+var _actionHandler;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/**
+ * Important: Do not rename `actionHandler` or the assignment pattern of property value.
+ * It is used to generate documentation
+ */
+var actionHandler = (_actionHandler = {}, (0, _defineProperty2["default"])(_actionHandler, _actionTypes["default"].UPDATE_MAP, mapStateUpdaters.updateMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actionTypes["default"].FIT_BOUNDS, mapStateUpdaters.fitBoundsUpdater), (0, _defineProperty2["default"])(_actionHandler, _actionTypes["default"].TOGGLE_PERSPECTIVE, mapStateUpdaters.togglePerspectiveUpdater), (0, _defineProperty2["default"])(_actionHandler, _actionTypes["default"].RECEIVE_MAP_CONFIG, mapStateUpdaters.receiveMapConfigUpdater), (0, _defineProperty2["default"])(_actionHandler, _actionTypes["default"].RESET_MAP_CONFIG, mapStateUpdaters.resetMapConfigUpdater), (0, _defineProperty2["default"])(_actionHandler, _actionTypes["default"].TOGGLE_SPLIT_MAP, mapStateUpdaters.toggleSplitMapUpdater), _actionHandler);
+/* Reducer */
+
+var mapStateReducerFactory = function mapStateReducerFactory() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (// @ts-ignore
+    (0, _reduxActions.handleActions)(actionHandler, _objectSpread(_objectSpread(_objectSpread({}, mapStateUpdaters.INITIAL_MAP_STATE), initialState), {}, {
+      initialState: initialState
+    }))
+  );
+};
+
+exports.mapStateReducerFactory = mapStateReducerFactory;
+
+var _default = mapStateReducerFactory();
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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