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

package/dist/reducers/combined-updaters.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDataToMapComposed = exports.loadFilesSuccessUpdater = exports.addDataToMapUpdater = exports.defaultAddDataToMapOptions = exports.isValidConfig = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _uiStateUpdaters = require("./ui-state-updaters");
+
+var _visStateUpdaters = require("./vis-state-updaters");
+
+var _mapStateUpdaters = require("./map-state-updaters");
+
+var _mapStyleUpdaters = require("./map-style-updaters");
+
+var _dataUtils = require("../utils/data-utils");
+
+var _utils = require("../utils/utils");
+
+var _fileHandler = require("../processors/file-handler");
+
+var _composerHelpers = require("./composer-helpers");
+
+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; }
+
+// compose action to apply result multiple reducers, with the output of one
+
+/**
+ * Some actions will affect the entire kepler.lg instance state.
+ * The updaters for these actions is exported as `combinedUpdaters`. These updater take the entire instance state
+ * as the first argument. Read more about [Using updaters](../advanced-usage/using-updaters.md)
+ * @public
+ * @example
+ *
+ * import keplerGlReducer, {combinedUpdaters} from 'kepler.gl/reducers';
+ * // Root Reducer
+ * const reducers = combineReducers({
+ *  keplerGl: keplerGlReducer,
+ *  app: appReducer
+ * });
+ *
+ * const composedReducer = (state, action) => {
+ *  switch (action.type) {
+ *    // add data to map after receiving data from remote sources
+ *    case 'LOAD_REMOTE_RESOURCE_SUCCESS':
+ *      return {
+ *        ...state,
+ *        keplerGl: {
+ *          ...state.keplerGl,
+ *          // pass in kepler.gl instance state to combinedUpdaters
+ *          map:  combinedUpdaters.addDataToMapUpdater(
+ *           state.keplerGl.map,
+ *           {
+ *             payload: {
+ *               datasets: action.datasets,
+ *               options: {readOnly: true},
+ *               config: action.config
+ *              }
+ *            }
+ *          )
+ *        }
+ *      };
+ *  }
+ *  return reducers(state, action);
+ * };
+ *
+ * export default composedReducer;
+ */
+
+/* eslint-disable no-unused-vars */
+// @ts-ignore
+var combinedUpdaters = null;
+/* eslint-enable no-unused-vars */
+
+var isValidConfig = function isValidConfig(config) {
+  return (0, _utils.isPlainObject)(config) && (0, _utils.isPlainObject)(config.config) && config.version;
+};
+
+exports.isValidConfig = isValidConfig;
+var defaultAddDataToMapOptions = {
+  centerMap: true,
+  keepExistingConfig: false,
+  autoCreateLayers: true
+};
+/**
+ * Combine data and full configuration update in a single action
+ *
+ * @memberof combinedUpdaters
+ * @param {Object} state kepler.gl instance state, containing all subreducer state
+ * @param {Object} action
+ * @param {Object} action.payload `{datasets, options, config}`
+ * @param action.payload.datasets - ***required** datasets can be a dataset or an array of datasets
+ * Each dataset object needs to have `info` and `data` property.
+ * @param [action.payload.options] option object `{centerMap: true}`
+ * @param [action.payload.config] map config
+ * @param [action.payload.info] map info contains title and description
+ * @returns nextState
+ *
+ * @typedef {Object} Dataset
+ * @property info -info of a dataset
+ * @property info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.
+ * @property info.label - A display name of this dataset
+ * @property data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`
+ * @property data.fields - ***required** Array of fields,
+ * @property data.fields.name - ***required** Name of the field,
+ * @property data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`
+ *
+ * @type {typeof import('./combined-updaters').addDataToMapUpdater}
+ * @public
+ */
+
+exports.defaultAddDataToMapOptions = defaultAddDataToMapOptions;
+
+var addDataToMapUpdater = function addDataToMapUpdater(state, _ref) {
+  var payload = _ref.payload;
+  var datasets = payload.datasets,
+      config = payload.config,
+      info = payload.info;
+
+  var options = _objectSpread(_objectSpread({}, defaultAddDataToMapOptions), payload.options);
+
+  var parsedConfig = config;
+
+  if (isValidConfig(config)) {
+    // if passed in saved config
+    parsedConfig = state.visState.schema.parseSavedConfig(config);
+  }
+
+  var oldLayers = state.visState.layers;
+
+  var filterNewlyAddedLayers = function filterNewlyAddedLayers(layers) {
+    return layers.filter(function (nl) {
+      return !oldLayers.find(function (ol) {
+        return ol === nl;
+      });
+    });
+  }; // Returns undefined if not found, to make typescript happy
+
+
+  var findMapBoundsIfCentered = function findMapBoundsIfCentered(layers) {
+    var bounds = options.centerMap && (0, _dataUtils.findMapBounds)(layers);
+    return bounds ? bounds : undefined;
+  };
+
+  return (0, _composerHelpers.compose_)([(0, _composerHelpers.pick_)('visState')((0, _composerHelpers.apply_)(_visStateUpdaters.updateVisDataUpdater, {
+    datasets: datasets,
+    options: options,
+    config: parsedConfig
+  })), (0, _composerHelpers.if_)(info, (0, _composerHelpers.pick_)('visState')((0, _composerHelpers.apply_)(_visStateUpdaters.setMapInfoUpdater, {
+    info: info
+  }))), (0, _composerHelpers.with_)(function (_ref2) {
+    var visState = _ref2.visState;
+    return (0, _composerHelpers.pick_)('mapState')((0, _composerHelpers.apply_)(_mapStateUpdaters.receiveMapConfigUpdater, (0, _composerHelpers.payload_)({
+      config: parsedConfig,
+      options: options,
+      bounds: findMapBoundsIfCentered(filterNewlyAddedLayers(visState.layers))
+    })));
+  }), (0, _composerHelpers.pick_)('mapStyle')((0, _composerHelpers.apply_)(_mapStyleUpdaters.receiveMapConfigUpdater, (0, _composerHelpers.payload_)({
+    config: parsedConfig,
+    options: options
+  }))), (0, _composerHelpers.pick_)('uiState')((0, _composerHelpers.apply_)(_uiStateUpdaters.loadFilesSuccessUpdater, (0, _composerHelpers.payload_)(null))), (0, _composerHelpers.pick_)('uiState')((0, _composerHelpers.apply_)(_uiStateUpdaters.toggleModalUpdater, (0, _composerHelpers.payload_)(null))), (0, _composerHelpers.pick_)('uiState')((0, _composerHelpers.merge_)(options.hasOwnProperty('readOnly') ? {
+    readOnly: options.readOnly
+  } : {}))])(state);
+};
+/**
+ * @type {typeof import('./combined-updaters').loadFilesSuccessUpdater}
+ */
+
+
+exports.addDataToMapUpdater = addDataToMapUpdater;
+
+var loadFilesSuccessUpdater = function loadFilesSuccessUpdater(state, action) {
+  // still more to load
+  var payloads = (0, _fileHandler.filesToDataPayload)(action.result);
+  var nextState = (0, _composerHelpers.compose_)([(0, _composerHelpers.pick_)('visState')((0, _composerHelpers.merge_)({
+    fileLoading: false,
+    fileLoadingProgress: {}
+  }))])(state); // make multiple add data to map calls
+
+  var stateWithData = (0, _composerHelpers.compose_)(payloads.map(function (p) {
+    return (0, _composerHelpers.apply_)(addDataToMapUpdater, (0, _composerHelpers.payload_)(p));
+  }))(nextState);
+  return stateWithData;
+};
+
+exports.loadFilesSuccessUpdater = loadFilesSuccessUpdater;
+var addDataToMapComposed = addDataToMapUpdater;
+exports.addDataToMapComposed = addDataToMapComposed;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/reducers/combined-updaters.js"],"names":["combinedUpdaters","isValidConfig","config","version","defaultAddDataToMapOptions","centerMap","keepExistingConfig","autoCreateLayers","addDataToMapUpdater","state","payload","datasets","info","options","parsedConfig","visState","schema","parseSavedConfig","oldLayers","layers","filterNewlyAddedLayers","filter","nl","find","ol","findMapBoundsIfCentered","bounds","undefined","visStateUpdateVisDataUpdater","setMapInfoUpdater","stateMapConfigUpdater","styleMapConfigUpdater","uiStateLoadFilesSuccessUpdater","toggleModalUpdater","hasOwnProperty","readOnly","loadFilesSuccessUpdater","action","payloads","result","nextState","fileLoading","fileLoadingProgress","stateWithData","map","p","addDataToMapComposed"],"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 {\n  toggleModalUpdater,\n  loadFilesSuccessUpdater as uiStateLoadFilesSuccessUpdater\n} from './ui-state-updaters';\nimport {\n  updateVisDataUpdater as visStateUpdateVisDataUpdater,\n  setMapInfoUpdater\n} from './vis-state-updaters';\nimport {receiveMapConfigUpdater as stateMapConfigUpdater} from './map-state-updaters';\nimport {receiveMapConfigUpdater as styleMapConfigUpdater} from './map-style-updaters';\nimport {findMapBounds} from 'utils/data-utils';\nimport {isPlainObject} from 'utils/utils';\nimport {filesToDataPayload} from 'processors/file-handler';\nimport {payload_, apply_, with_, if_, compose_, merge_, pick_} from './composer-helpers';\n\n// compose action to apply result multiple reducers, with the output of one\n\n/**\n * Some actions will affect the entire kepler.lg instance state.\n * The updaters for these actions is exported as `combinedUpdaters`. These updater take the entire instance state\n * as the first argument. Read more about [Using updaters](../advanced-usage/using-updaters.md)\n * @public\n * @example\n *\n * import keplerGlReducer, {combinedUpdaters} 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 *    // add data to map after receiving data from remote sources\n *    case 'LOAD_REMOTE_RESOURCE_SUCCESS':\n *      return {\n *        ...state,\n *        keplerGl: {\n *          ...state.keplerGl,\n *          // pass in kepler.gl instance state to combinedUpdaters\n *          map:  combinedUpdaters.addDataToMapUpdater(\n *           state.keplerGl.map,\n *           {\n *             payload: {\n *               datasets: action.datasets,\n *               options: {readOnly: true},\n *               config: action.config\n *              }\n *            }\n *          )\n *        }\n *      };\n *  }\n *  return reducers(state, action);\n * };\n *\n * export default composedReducer;\n */\n\n/* eslint-disable no-unused-vars */\n// @ts-ignore\nconst combinedUpdaters = null;\n/* eslint-enable no-unused-vars */\n\nexport const isValidConfig = config =>\n  isPlainObject(config) && isPlainObject(config.config) && config.version;\n\nexport const defaultAddDataToMapOptions = {\n  centerMap: true,\n  keepExistingConfig: false,\n  autoCreateLayers: true\n};\n\n/**\n * Combine data and full configuration update in a single action\n *\n * @memberof combinedUpdaters\n * @param {Object} state kepler.gl instance state, containing all subreducer state\n * @param {Object} action\n * @param {Object} action.payload `{datasets, options, config}`\n * @param action.payload.datasets - ***required** datasets can be a dataset or an array of datasets\n * Each dataset object needs to have `info` and `data` property.\n * @param [action.payload.options] option object `{centerMap: true}`\n * @param [action.payload.config] map config\n * @param [action.payload.info] map info contains title and description\n * @returns nextState\n *\n * @typedef {Object} Dataset\n * @property info -info of a dataset\n * @property info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.\n * @property info.label - A display name of this dataset\n * @property data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`\n * @property data.fields - ***required** Array of fields,\n * @property data.fields.name - ***required** Name of the field,\n * @property data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`\n *\n * @type {typeof import('./combined-updaters').addDataToMapUpdater}\n * @public\n */\nexport const addDataToMapUpdater = (state, {payload}) => {\n  const {datasets, config, info} = payload;\n\n  const options = {\n    ...defaultAddDataToMapOptions,\n    ...payload.options\n  };\n\n  let parsedConfig = config;\n\n  if (isValidConfig(config)) {\n    // if passed in saved config\n    parsedConfig = state.visState.schema.parseSavedConfig(config);\n  }\n  const oldLayers = state.visState.layers;\n  const filterNewlyAddedLayers = layers => layers.filter(nl => !oldLayers.find(ol => ol === nl));\n\n  // Returns undefined if not found, to make typescript happy\n  const findMapBoundsIfCentered = layers => {\n    const bounds = options.centerMap && findMapBounds(layers);\n    return bounds ? bounds : undefined;\n  };\n\n  return compose_([\n    pick_('visState')(\n      apply_(visStateUpdateVisDataUpdater, {\n        datasets,\n        options,\n        config: parsedConfig\n      })\n    ),\n\n    if_(info, pick_('visState')(apply_(setMapInfoUpdater, {info}))),\n\n    with_(({visState}) =>\n      pick_('mapState')(\n        apply_(\n          stateMapConfigUpdater,\n          payload_({\n            config: parsedConfig,\n            options,\n            bounds: findMapBoundsIfCentered(filterNewlyAddedLayers(visState.layers))\n          })\n        )\n      )\n    ),\n\n    pick_('mapStyle')(apply_(styleMapConfigUpdater, payload_({config: parsedConfig, options}))),\n\n    pick_('uiState')(apply_(uiStateLoadFilesSuccessUpdater, payload_(null))),\n\n    pick_('uiState')(apply_(toggleModalUpdater, payload_(null))),\n\n    pick_('uiState')(merge_(options.hasOwnProperty('readOnly') ? {readOnly: options.readOnly} : {}))\n  ])(state);\n};\n\n/**\n * @type {typeof import('./combined-updaters').loadFilesSuccessUpdater}\n */\nexport const loadFilesSuccessUpdater = (state, action) => {\n  // still more to load\n  const payloads = filesToDataPayload(action.result);\n  const nextState = compose_([\n    pick_('visState')(\n      merge_({\n        fileLoading: false,\n        fileLoadingProgress: {}\n      })\n    )\n  ])(state);\n  // make multiple add data to map calls\n  const stateWithData = compose_(payloads.map(p => apply_(addDataToMapUpdater, payload_(p))))(\n    nextState\n  );\n  return stateWithData;\n};\n\nexport const addDataToMapComposed = addDataToMapUpdater;\n"]}

package/dist/reducers/composer-helpers.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.log = log;
+exports.payload_ = payload_;
+exports.apply_ = apply_;
+exports.with_ = with_;
+exports.if_ = if_;
+exports.compose_ = compose_;
+exports.merge_ = merge_;
+exports.pick_ = pick_;
+exports.swap_ = swap_;
+exports.findById = findById;
+exports.map_ = map_;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _console = _interopRequireDefault(require("global/console"));
+
+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; }
+
+var identity = function identity(state) {
+  return state;
+};
+/* eslint-disable no-unused-vars */
+// @ts-ignore
+
+
+function log(text) {
+  return function (value) {
+    return _console["default"].log(text, value);
+  };
+}
+/* eslint-enable no-unused-vars */
+
+
+function payload_(p) {
+  return {
+    payload: p
+  };
+}
+
+function apply_(updater, payload) {
+  return function (state) {
+    return updater(state, payload);
+  };
+}
+
+function with_(fn) {
+  return function (state) {
+    return fn(state)(state);
+  };
+}
+
+function if_(pred, fn) {
+  return pred ? fn : identity;
+}
+
+function compose_(fns) {
+  return function (state) {
+    return fns.reduce(function (state2, fn) {
+      return fn(state2);
+    }, state);
+  };
+}
+
+function merge_(obj) {
+  return function (state) {
+    return _objectSpread(_objectSpread({}, state), obj);
+  };
+}
+
+function pick_(prop) {
+  return function (fn) {
+    return function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, (0, _defineProperty2["default"])({}, prop, fn(state[prop])));
+    };
+  };
+}
+
+function swap_(item) {
+  return function (arr) {
+    return arr.map(function (a) {
+      return a.id === item.id ? item : a;
+    });
+  };
+}
+
+function findById(id) {
+  return function (arr) {
+    return arr.find(function (a) {
+      return a.id === id;
+    });
+  };
+}
+
+function map_(fn) {
+  return function (arr) {
+    return arr.map(function (e) {
+      return fn(e);
+    });
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/reducers/composers.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _actionTypes = _interopRequireDefault(require("../constants/action-types"));
+
+var combinedUpdaters = _interopRequireWildcard(require("./combined-updaters"));
+
+var _actionHandler;
+
+/**
+ * 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"].ADD_DATA_TO_MAP, combinedUpdaters.addDataToMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actionTypes["default"].LOAD_FILES_SUCCESS, combinedUpdaters.loadFilesSuccessUpdater), _actionHandler);
+var _default = actionHandler;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/reducers/core.js

@@ -0,0 +1,156 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.providerStateLens = exports.uiStateLens = exports.visStateLens = exports.mapStyleLens = exports.mapStateLens = exports["default"] = exports.coreReducerFactory = void 0;
+
+var _redux = require("redux");
+
+var _visState = require("./vis-state");
+
+var _mapState = require("./map-state");
+
+var _mapStyle = require("./map-style");
+
+var _uiState = require("./ui-state");
+
+var _providerState = require("./provider-state");
+
+var _composers = _interopRequireDefault(require("./composers"));
+
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/**
+ * @type {typeof import('./core').combineReducers_}
+ */
+var combineReducers_ = _redux.combineReducers;
+
+var combined = function combined() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return combineReducers_({
+    visState: (0, _visState.visStateReducerFactory)(initialState.visState),
+    mapState: (0, _mapState.mapStateReducerFactory)(initialState.mapState),
+    mapStyle: (0, _mapStyle.mapStyleReducerFactory)(initialState.mapStyle),
+    uiState: (0, _uiState.uiStateReducerFactory)(initialState.uiState),
+    providerState: (0, _providerState.providerStateReducerFactory)(initialState.providerState)
+  });
+};
+
+var coreReducerFactory = function coreReducerFactory() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return function (state, action) {
+    if (_composers["default"][action.type]) {
+      return _composers["default"][action.type](state, action);
+    }
+
+    return combined(initialState)(state, action);
+  };
+};
+
+exports.coreReducerFactory = coreReducerFactory;
+
+var _default = coreReducerFactory();
+/**
+ * Connect subreducer `mapState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+
+
+exports["default"] = _default;
+
+var mapStateLens = function mapStateLens(reduxState) {
+  return {
+    mapState: reduxState.mapState
+  };
+};
+/**
+ * Connect subreducer `mapStyle`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+
+
+exports.mapStateLens = mapStateLens;
+
+var mapStyleLens = function mapStyleLens(reduxState) {
+  return {
+    mapStyle: reduxState.mapStyle
+  };
+};
+/**
+ * Connect subreducer `visState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+
+
+exports.mapStyleLens = mapStyleLens;
+
+var visStateLens = function visStateLens(reduxState) {
+  return {
+    visState: reduxState.visState
+  };
+};
+/**
+ * Connect subreducer `uiState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+
+
+exports.visStateLens = visStateLens;
+
+var uiStateLens = function uiStateLens(reduxState) {
+  return {
+    uiState: reduxState.uiState
+  };
+};
+/**
+ * Connect subreducer `providerState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+
+
+exports.uiStateLens = uiStateLens;
+
+var providerStateLens = function providerStateLens(reduxState) {
+  return {
+    providerState: reduxState.providerState
+  };
+};
+
+exports.providerStateLens = providerStateLens;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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