@kepler.gl/reducers 3.0.0-alpha.0 → 3.0.0-alpha.2

package/dist/combined-updaters.d.ts

@@ -1,7 +1,7 @@
 import { MapState, UiState, AddDataToMapPayload } from '@kepler.gl/types';
 import { MapStyle } from './map-style-updaters';
 import { ProviderState } from './provider-state-updaters';
-import { loadFilesSuccessUpdaterAction } from '@kepler.gl/actions';
+import { loadFilesSuccessUpdaterAction, MapStyleChangeUpdaterAction, LayerTypeChangeUpdaterAction, ToggleSplitMapUpdaterAction, ReplaceDataInMapPayload } from '@kepler.gl/actions';
 import { VisState } from '@kepler.gl/schemas';
 export declare type KeplerGlState = {
     visState: VisState;
@@ -15,6 +15,7 @@ export declare const defaultAddDataToMapOptions: {
     centerMap: boolean;
     keepExistingConfig: boolean;
     autoCreateLayers: boolean;
+    autoCreateTooltips: boolean;
 };
 /**
  * Combine data and full configuration update in a single action
@@ -48,3 +49,31 @@ export declare const loadFilesSuccessUpdater: (state: KeplerGlState, action: loa
 export declare const addDataToMapComposed: (state: KeplerGlState, { payload }: {
     payload: AddDataToMapPayload;
 }) => KeplerGlState;
+/**
+ * Updater that changes the map style by calling mapStyleChangeUpdater on visState.
+ * In addition to that, it does the following:
+ *
+ *   1. Update map overlay blending mode in accordance with the colorMode of the
+ *      base map, but only if it's not in the `normal` mode.
+ *
+ *   2. Update all the layers which have the `darkBaseMapEnabled` config setting
+ *      adjusting it in accordance with the colorMode of the base map.
+ *
+ */
+export declare const combinedMapStyleChangeUpdater: (state: KeplerGlState, action: MapStyleChangeUpdaterAction) => KeplerGlState;
+/**
+ * Updater that changes the layer type by calling `layerTypeChangeUpdater` on visState.
+ * In addition to that, if the new layer type has the `darkBaseMapEnabled` config
+ * setting, we adjust it in accordance with the colorMode of the base map.s
+ */
+export declare const combinedLayerTypeChangeUpdater: (state: KeplerGlState, action: LayerTypeChangeUpdaterAction) => KeplerGlState;
+/**
+ * Make mapLegend active when toggleSplitMap action is called
+ */
+export declare const toggleSplitMapUpdater: (state: KeplerGlState, action: ToggleSplitMapUpdaterAction) => KeplerGlState;
+/**
+ * Updater replace a dataset in state
+ */
+export declare const replaceDataInMapUpdater: (state: KeplerGlState, { payload }: {
+    payload: ReplaceDataInMapPayload;
+}) => KeplerGlState;

package/dist/combined-updaters.js

@@ -1,23 +1,3 @@
-// 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.
-
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
@@ -25,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.addDataToMapComposed = exports.loadFilesSuccessUpdater = exports.addDataToMapUpdater = exports.defaultAddDataToMapOptions = exports.isValidConfig = void 0;
+exports.replaceDataInMapUpdater = exports.toggleSplitMapUpdater = exports.combinedLayerTypeChangeUpdater = exports.combinedMapStyleChangeUpdater = exports.addDataToMapComposed = exports.loadFilesSuccessUpdater = exports.addDataToMapUpdater = exports.defaultAddDataToMapOptions = exports.isValidConfig = void 0;
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
@@ -45,6 +25,8 @@ var _utils = require("@kepler.gl/utils");
 
 var _dataUtils = require("./data-utils");
 
+var _constants = require("@kepler.gl/constants");
+
 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; }
@@ -106,7 +88,8 @@ exports.isValidConfig = isValidConfig;
 var defaultAddDataToMapOptions = {
   centerMap: true,
   keepExistingConfig: false,
-  autoCreateLayers: true
+  autoCreateLayers: true,
+  autoCreateTooltips: true
 };
 /**
  * Combine data and full configuration update in a single action
@@ -137,12 +120,25 @@ var defaultAddDataToMapOptions = {
 exports.defaultAddDataToMapOptions = defaultAddDataToMapOptions;
 
 var addDataToMapUpdater = function addDataToMapUpdater(state, _ref) {
+  var _datasets$, _datasets$2, _datasets$3;
+
   var payload = _ref.payload;
   var datasets = payload.datasets,
       config = payload.config,
       info = payload.info;
 
-  var options = _objectSpread(_objectSpread({}, defaultAddDataToMapOptions), payload.options); // @ts-expect-error
+  var options = _objectSpread(_objectSpread({}, defaultAddDataToMapOptions), payload.options); // check if progresive loading dataset by bataches, and update visState directly
+
+
+  var isProgressiveLoading = Array.isArray(datasets) && ((_datasets$ = datasets[0]) === null || _datasets$ === void 0 ? void 0 : _datasets$.info.format) === 'arrow' && ((_datasets$2 = datasets[0]) === null || _datasets$2 === void 0 ? void 0 : _datasets$2.info.id) && ((_datasets$3 = datasets[0]) === null || _datasets$3 === void 0 ? void 0 : _datasets$3.info.id) in state.visState.datasets;
+
+  if (isProgressiveLoading) {
+    return (0, _composerHelpers.compose_)([(0, _composerHelpers.pick_)('visState')((0, _composerHelpers.apply_)(_visStateUpdaters.updateVisDataUpdater, {
+      datasets: datasets,
+      options: options,
+      config: config
+    }))])(state);
+  } // @ts-expect-error
 
 
   var parsedConfig = config;
@@ -208,5 +204,220 @@ var loadFilesSuccessUpdater = function loadFilesSuccessUpdater(state, action) {
 
 exports.loadFilesSuccessUpdater = loadFilesSuccessUpdater;
 var addDataToMapComposed = addDataToMapUpdater;
+/**
+ * Helper which updates map overlay blending mode in visState,
+ * but only if it's not currently in the `normal` mode.
+ */
+
 exports.addDataToMapComposed = addDataToMapComposed;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/combined-updaters.ts"],"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","Boolean","setMapInfoUpdater","stateMapConfigUpdater","styleMapConfigUpdater","uiStateLoadFilesSuccessUpdater","toggleModalUpdater","hasOwnProperty","readOnly","loadFilesSuccessUpdater","action","payloads","result","nextState","fileLoading","fileLoadingProgress","stateWithData","map","p","addDataToMapComposed"],"mappings":";;;;;;;;;;;AAoBA;;AAIA;;AAIA;;AACA;;AACA;;AACA;;AAOA;;AACA;;;;;;AAUA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,IAAMA,gBAAgB,GAAG,IAAzB;AACA;;AAEO,IAAMC,aAAa,GAAG,SAAhBA,aAAgB,CAAAC,MAAM;AAAA,SACjC,0BAAcA,MAAd,KAAyB,0BAAcA,MAAM,CAACA,MAArB,CAAzB,IAAyDA,MAAM,CAACC,OAD/B;AAAA,CAA5B;;;AAGA,IAAMC,0BAA0B,GAAG;AACxCC,EAAAA,SAAS,EAAE,IAD6B;AAExCC,EAAAA,kBAAkB,EAAE,KAFoB;AAGxCC,EAAAA,gBAAgB,EAAE;AAHsB,CAAnC;AAMP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AACO,IAAMC,mBAAmB,GAAG,SAAtBA,mBAAsB,CACjCC,KADiC,QAGf;AAAA,MADjBC,OACiB,QADjBA,OACiB;AAAA,MACXC,QADW,GACeD,OADf,CACXC,QADW;AAAA,MACDT,MADC,GACeQ,OADf,CACDR,MADC;AAAA,MACOU,IADP,GACeF,OADf,CACOE,IADP;;AAGlB,MAAMC,OAAO,mCACRT,0BADQ,GAERM,OAAO,CAACG,OAFA,CAAb,CAHkB,CAQlB;;;AACA,MAAIC,YAA0B,GAAGZ,MAAjC;;AAEA,MAAID,aAAa,CAACC,MAAD,CAAjB,EAA2B;AACzB;AACA;AACAY,IAAAA,YAAY,GAAGL,KAAK,CAACM,QAAN,CAAeC,MAAf,CAAsBC,gBAAtB,CAAuCf,MAAvC,CAAf;AACD;;AACD,MAAMgB,SAAS,GAAGT,KAAK,CAACM,QAAN,CAAeI,MAAjC;;AACA,MAAMC,sBAAsB,GAAG,SAAzBA,sBAAyB,CAACD,MAAD;AAAA,WAC7BA,MAAM,CAACE,MAAP,CAAc,UAAAC,EAAE;AAAA,aAAI,CAACJ,SAAS,CAACK,IAAV,CAAe,UAAAC,EAAE;AAAA,eAAIA,EAAE,KAAKF,EAAX;AAAA,OAAjB,CAAL;AAAA,KAAhB,CAD6B;AAAA,GAA/B,CAjBkB,CAoBlB;;;AACA,MAAMG,uBAAuB,GAAG,SAA1BA,uBAA0B,CAACN,MAAD,EAAqB;AACnD,QAAMO,MAAM,GAAGb,OAAO,CAACR,SAAR,IAAqB,8BAAcc,MAAd,CAApC;AACA,WAAOO,MAAM,GAAGA,MAAH,GAAYC,SAAzB;AACD,GAHD;;AAKA,SAAO,+BAAwB,CAC7B,4BAAM,UAAN,EACE,6BAAsBC,sCAAtB,EAAoD;AAClDjB,IAAAA,QAAQ,EAARA,QADkD;AAElDE,IAAAA,OAAO,EAAPA,OAFkD;AAGlDX,IAAAA,MAAM,EAAEY;AAH0C,GAApD,CADF,CAD6B,EAS7B,0BACEe,OAAO,CAACjB,IAAD,CADT,EAEE,4BAAM,UAAN,EACE,6BAAsBkB,mCAAtB,EAAyC;AAAClB,IAAAA,IAAI,EAAJA;AAAD,GAAzC,CADF,CAFF,CAT6B,EAgB7B,4BAAM;AAAA,QAAEG,QAAF,SAAEA,QAAF;AAAA,WACJ,4BAAM,UAAN,EACE,6BACEgB,yCADF,EAEE,+BAAS;AACP7B,MAAAA,MAAM,EAAEY,YADD;AAEPD,MAAAA,OAAO,EAAPA,OAFO;AAGPa,MAAAA,MAAM,EAAED,uBAAuB,CAACL,sBAAsB,CAACL,QAAQ,CAACI,MAAV,CAAvB;AAHxB,KAAT,CAFF,CADF,CADI;AAAA,GAAN,CAhB6B,EA4B7B,4BAAM,UAAN,EAAkB,6BAAOa,yCAAP,EAA8B,+BAAS;AAAC9B,IAAAA,MAAM,EAAEY,YAAT;AAAuBD,IAAAA,OAAO,EAAPA;AAAvB,GAAT,CAA9B,CAAlB,CA5B6B,EA6B7B,4BAAM,SAAN,EAAiB,6BAAOoB,wCAAP,EAAuC,+BAAS,IAAT,CAAvC,CAAjB,CA7B6B,EA8B7B,4BAAM,SAAN,EAAiB,6BAAOC,mCAAP,EAA2B,+BAAS,IAAT,CAA3B,CAAjB,CA9B6B,EA+B7B,4BAAM,SAAN,EAAiB,6BAAOrB,OAAO,CAACsB,cAAR,CAAuB,UAAvB,IAAqC;AAACC,IAAAA,QAAQ,EAAEvB,OAAO,CAACuB;AAAnB,GAArC,GAAoE,EAA3E,CAAjB,CA/B6B,CAAxB,EAgCJ3B,KAhCI,CAAP;AAiCD,CA9DM;;;;AAgEA,IAAM4B,uBAAuB,GAAG,SAA1BA,uBAA0B,CACrC5B,KADqC,EAErC6B,MAFqC,EAGnB;AAClB;AACA,MAAMC,QAAQ,GAAG,oCAAmBD,MAAM,CAACE,MAA1B,CAAjB;AACA,MAAMC,SAAS,GAAG,+BAAS,CACzB,4BAAM,UAAN,EACE,6BAAO;AACLC,IAAAA,WAAW,EAAE,KADR;AAELC,IAAAA,mBAAmB,EAAE;AAFhB,GAAP,CADF,CADyB,CAAT,EAOflC,KAPe,CAAlB,CAHkB,CAWlB;;AACA,MAAMmC,aAAa,GAAG,+BAASL,QAAQ,CAACM,GAAT,CAAa,UAAAC,CAAC;AAAA,WAAI,6BAAOtC,mBAAP,EAA4B,+BAASsC,CAAT,CAA5B,CAAJ;AAAA,GAAd,CAAT,EACpBL,SADoB,CAAtB;AAGA,SAAOG,aAAP;AACD,CAnBM;;;AAqBA,IAAMG,oBAAoB,GAAGvC,mBAA7B","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 {filesToDataPayload} from '@kepler.gl/processors';\nimport {payload_, apply_, with_, if_, compose_, merge_, pick_} from './composer-helpers';\nimport {MapState, UiState, AddDataToMapPayload, ParsedConfig} from '@kepler.gl/types';\nimport {MapStyle} from './map-style-updaters';\nimport {ProviderState} from './provider-state-updaters';\nimport {loadFilesSuccessUpdaterAction} from '@kepler.gl/actions';\nimport {VisState} from '@kepler.gl/schemas';\nimport {Layer} from '@kepler.gl/layers';\nimport {isPlainObject} from '@kepler.gl/utils';\nimport {findMapBounds} from './data-utils';\n\nexport type KeplerGlState = {\n  visState: VisState;\n  mapState: MapState;\n  mapStyle: MapStyle;\n  uiState: UiState;\n  providerState: ProviderState;\n};\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 * @public\n */\nexport const addDataToMapUpdater = (\n  state: KeplerGlState,\n  {payload}: {payload: AddDataToMapPayload}\n): KeplerGlState => {\n  const {datasets, config, info} = payload;\n\n  const options = {\n    ...defaultAddDataToMapOptions,\n    ...payload.options\n  };\n\n  // @ts-expect-error\n  let parsedConfig: ParsedConfig = config;\n\n  if (isValidConfig(config)) {\n    // if passed in saved config\n    // @ts-expect-error\n    parsedConfig = state.visState.schema.parseSavedConfig(config);\n  }\n  const oldLayers = state.visState.layers;\n  const filterNewlyAddedLayers = (layers: Layer[]) =>\n    layers.filter(nl => !oldLayers.find(ol => ol === nl));\n\n  // Returns undefined if not found, to make typescript happy\n  const findMapBoundsIfCentered = (layers: Layer[]) => {\n    const bounds = options.centerMap && findMapBounds(layers);\n    return bounds ? bounds : undefined;\n  };\n\n  return compose_<KeplerGlState>([\n    pick_('visState')(\n      apply_<VisState, any>(visStateUpdateVisDataUpdater, {\n        datasets,\n        options,\n        config: parsedConfig\n      })\n    ),\n\n    if_(\n      Boolean(info),\n      pick_('visState')(\n        apply_<VisState, any>(setMapInfoUpdater, {info})\n      )\n    ),\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    pick_('mapStyle')(apply_(styleMapConfigUpdater, payload_({config: parsedConfig, options}))),\n    pick_('uiState')(apply_(uiStateLoadFilesSuccessUpdater, payload_(null))),\n    pick_('uiState')(apply_(toggleModalUpdater, payload_(null))),\n    pick_('uiState')(merge_(options.hasOwnProperty('readOnly') ? {readOnly: options.readOnly} : {}))\n  ])(state);\n};\n\nexport const loadFilesSuccessUpdater = (\n  state: KeplerGlState,\n  action: loadFilesSuccessUpdaterAction\n): KeplerGlState => {\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 as KeplerGlState;\n};\n\nexport const addDataToMapComposed = addDataToMapUpdater;\n"]}
+
+var updateOverlayBlending = function updateOverlayBlending(overlayBlending) {
+  return function (visState) {
+    if (visState.overlayBlending !== _constants.OVERLAY_BLENDINGS.normal.value) {
+      return _objectSpread(_objectSpread({}, visState), {}, {
+        overlayBlending: overlayBlending
+      });
+    }
+
+    return visState;
+  };
+};
+/**
+ * Helper which updates `darkBaseMapEnabled` in all the layers in visState which
+ * have this config setting (or in one specific layer if the `layerId` param is provided).
+ */
+
+
+var updateDarkBaseMapLayers = function updateDarkBaseMapLayers(darkBaseMapEnabled) {
+  var layerId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return function (visState) {
+    return _objectSpread(_objectSpread({}, visState), {}, {
+      layers: visState.layers.map(function (layer) {
+        if (!layerId || layer.id === layerId) {
+          if (layer.visConfigSettings.hasOwnProperty('darkBaseMapEnabled')) {
+            var visConfig = layer.config.visConfig;
+            return layer.updateLayerConfig({
+              visConfig: _objectSpread(_objectSpread({}, visConfig), {}, {
+                darkBaseMapEnabled: darkBaseMapEnabled
+              })
+            });
+          }
+        }
+
+        return layer;
+      })
+    });
+  };
+};
+/**
+ * Updater that changes the map style by calling mapStyleChangeUpdater on visState.
+ * In addition to that, it does the following:
+ *
+ *   1. Update map overlay blending mode in accordance with the colorMode of the
+ *      base map, but only if it's not in the `normal` mode.
+ *
+ *   2. Update all the layers which have the `darkBaseMapEnabled` config setting
+ *      adjusting it in accordance with the colorMode of the base map.
+ *
+ */
+
+
+var combinedMapStyleChangeUpdater = function combinedMapStyleChangeUpdater(state, action) {
+  var payload = action.payload;
+  var mapStyle = state.mapStyle;
+
+  var getColorMode = function getColorMode(key) {
+    var _mapStyle$mapStyles$k;
+
+    return (_mapStyle$mapStyles$k = mapStyle.mapStyles[key]) === null || _mapStyle$mapStyles$k === void 0 ? void 0 : _mapStyle$mapStyles$k.colorMode;
+  };
+
+  var prevColorMode = getColorMode(mapStyle.styleType);
+  var nextColorMode = getColorMode(payload.styleType);
+  var visState = state.visState;
+
+  if (nextColorMode !== prevColorMode) {
+    switch (nextColorMode) {
+      case _constants.BASE_MAP_COLOR_MODES.DARK:
+        visState = (0, _composerHelpers.compose_)([updateOverlayBlending(_constants.OVERLAY_BLENDINGS.screen.value), updateDarkBaseMapLayers(true)])(visState);
+        break;
+
+      case _constants.BASE_MAP_COLOR_MODES.LIGHT:
+        visState = (0, _composerHelpers.compose_)([updateOverlayBlending(_constants.OVERLAY_BLENDINGS.darken.value), updateDarkBaseMapLayers(false)])(visState);
+        break;
+
+      default: // do nothing
+
+    }
+  }
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    visState: visState,
+    mapStyle: (0, _mapStyleUpdaters.mapStyleChangeUpdater)(mapStyle, {
+      payload: _objectSpread({}, payload)
+    })
+  });
+};
+/**
+ * Updater that changes the layer type by calling `layerTypeChangeUpdater` on visState.
+ * In addition to that, if the new layer type has the `darkBaseMapEnabled` config
+ * setting, we adjust it in accordance with the colorMode of the base map.s
+ */
+
+
+exports.combinedMapStyleChangeUpdater = combinedMapStyleChangeUpdater;
+
+var combinedLayerTypeChangeUpdater = function combinedLayerTypeChangeUpdater(state, action) {
+  var visState = state.visState;
+  var oldLayerIndex = visState.layers.findIndex(function (layer) {
+    return layer === action.oldLayer;
+  });
+  visState = (0, _visStateUpdaters.layerTypeChangeUpdater)(visState, action);
+  var newLayer = visState.layers[oldLayerIndex];
+
+  if (newLayer !== null && newLayer !== void 0 && newLayer.visConfigSettings.hasOwnProperty('darkBaseMapEnabled')) {
+    var mapStyle = state.mapStyle;
+    var colorMode = mapStyle.mapStyles[mapStyle.styleType].colorMode;
+    var darkBaseMapEnabled = newLayer.config.visConfig.darkBaseMapEnabled;
+
+    switch (colorMode) {
+      case _constants.BASE_MAP_COLOR_MODES.DARK:
+        if (!darkBaseMapEnabled) {
+          visState = updateDarkBaseMapLayers(true, newLayer.id)(visState);
+        }
+
+        break;
+
+      case _constants.BASE_MAP_COLOR_MODES.LIGHT:
+        if (darkBaseMapEnabled) {
+          visState = updateDarkBaseMapLayers(false, newLayer.id)(visState);
+        }
+
+        break;
+
+      default: // do nothing
+
+    }
+  }
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    visState: visState
+  });
+};
+/**
+ * Make mapLegend active when toggleSplitMap action is called
+ */
+
+
+exports.combinedLayerTypeChangeUpdater = combinedLayerTypeChangeUpdater;
+
+var toggleSplitMapUpdater = function toggleSplitMapUpdater(state, action) {
+  var _newState$uiState$map, _newState$uiState$map2;
+
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    visState: (0, _visStateUpdaters.toggleSplitMapUpdater)(state.visState, action),
+    uiState: (0, _uiStateUpdaters.toggleSplitMapUpdater)(state.uiState),
+    mapState: (0, _mapStateUpdaters.toggleSplitMapUpdater)(state.mapState, action)
+  });
+
+  var isSplit = newState.visState.splitMaps.length !== 0;
+  var isLegendActive = (_newState$uiState$map = newState.uiState.mapControls) === null || _newState$uiState$map === void 0 ? void 0 : (_newState$uiState$map2 = _newState$uiState$map.mapLegend) === null || _newState$uiState$map2 === void 0 ? void 0 : _newState$uiState$map2.active;
+
+  if (isSplit && !isLegendActive) {
+    newState.uiState = (0, _uiStateUpdaters.toggleMapControlUpdater)(newState.uiState, {
+      payload: {
+        panelId: 'mapLegend',
+        index: action.payload
+      }
+    });
+  }
+
+  return newState;
+};
+
+exports.toggleSplitMapUpdater = toggleSplitMapUpdater;
+var defaultReplaceDataToMapOptions = {
+  keepExistingConfig: true,
+  centerMap: true,
+  autoCreateLayers: false
+};
+/**
+ * Updater replace a dataset in state
+ */
+
+var replaceDataInMapUpdater = function replaceDataInMapUpdater(state, _ref3) {
+  var payload = _ref3.payload;
+  var datasetToReplaceId = payload.datasetToReplaceId,
+      datasetToUse = payload.datasetToUse,
+      _payload$options = payload.options,
+      options = _payload$options === void 0 ? {} : _payload$options;
+
+  var addDataToMapOptions = _objectSpread(_objectSpread({}, defaultReplaceDataToMapOptions), options); // check if dataset is there
+
+
+  if (!state.visState.datasets[datasetToReplaceId]) {
+    return state;
+  } // datasetToUse is ProtoDataset
+
+
+  var dataIdToUse = datasetToUse.info.id;
+
+  if (!dataIdToUse) {
+    return state;
+  } // remove dataset and put dependencies in toBeMerged
+
+
+  var preparedState = _objectSpread(_objectSpread({}, state), {}, {
+    visState: (0, _visStateUpdaters.prepareStateForDatasetReplace)(state.visState, datasetToReplaceId, dataIdToUse)
+  });
+
+  var nextState = addDataToMapUpdater(preparedState, (0, _composerHelpers.payload_)({
+    datasets: datasetToUse,
+    // should zoom to new dataset
+    options: addDataToMapOptions
+  }));
+  return nextState;
+};
+
+exports.replaceDataInMapUpdater = replaceDataInMapUpdater;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/combined-updaters.ts"],"names":["combinedUpdaters","isValidConfig","config","version","defaultAddDataToMapOptions","centerMap","keepExistingConfig","autoCreateLayers","autoCreateTooltips","addDataToMapUpdater","state","payload","datasets","info","options","isProgressiveLoading","Array","isArray","format","id","visState","visStateUpdateVisDataUpdater","parsedConfig","schema","parseSavedConfig","oldLayers","layers","filterNewlyAddedLayers","filter","nl","find","ol","findMapBoundsIfCentered","bounds","undefined","Boolean","setMapInfoUpdater","stateMapConfigUpdater","styleMapConfigUpdater","uiStateLoadFilesSuccessUpdater","toggleModalUpdater","hasOwnProperty","readOnly","loadFilesSuccessUpdater","action","payloads","result","nextState","fileLoading","fileLoadingProgress","stateWithData","map","p","addDataToMapComposed","updateOverlayBlending","overlayBlending","OVERLAY_BLENDINGS","normal","value","updateDarkBaseMapLayers","darkBaseMapEnabled","layerId","layer","visConfigSettings","visConfig","updateLayerConfig","combinedMapStyleChangeUpdater","mapStyle","getColorMode","key","mapStyles","colorMode","prevColorMode","styleType","nextColorMode","BASE_MAP_COLOR_MODES","DARK","screen","LIGHT","darken","combinedLayerTypeChangeUpdater","oldLayerIndex","findIndex","oldLayer","newLayer","toggleSplitMapUpdater","newState","uiState","mapState","isSplit","splitMaps","length","isLegendActive","mapControls","mapLegend","active","panelId","index","defaultReplaceDataToMapOptions","replaceDataInMapUpdater","datasetToReplaceId","datasetToUse","addDataToMapOptions","dataIdToUse","preparedState"],"mappings":";;;;;;;;;;;AAGA;;AAMA;;AAOA;;AAIA;;AAIA;;AACA;;AAaA;;AACA;;AACA;;;;;;AAUA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,IAAMA,gBAAgB,GAAG,IAAzB;AACA;;AAEO,IAAMC,aAAa,GAAG,SAAhBA,aAAgB,CAAAC,MAAM;AAAA,SACjC,0BAAcA,MAAd,KAAyB,0BAAcA,MAAM,CAACA,MAArB,CAAzB,IAAyDA,MAAM,CAACC,OAD/B;AAAA,CAA5B;;;AAGA,IAAMC,0BAA0B,GAAG;AACxCC,EAAAA,SAAS,EAAE,IAD6B;AAExCC,EAAAA,kBAAkB,EAAE,KAFoB;AAGxCC,EAAAA,gBAAgB,EAAE,IAHsB;AAIxCC,EAAAA,kBAAkB,EAAE;AAJoB,CAAnC;AAOP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AACO,IAAMC,mBAAmB,GAAG,SAAtBA,mBAAsB,CACjCC,KADiC,QAGf;AAAA;;AAAA,MADjBC,OACiB,QADjBA,OACiB;AAAA,MACXC,QADW,GACeD,OADf,CACXC,QADW;AAAA,MACDV,MADC,GACeS,OADf,CACDT,MADC;AAAA,MACOW,IADP,GACeF,OADf,CACOE,IADP;;AAGlB,MAAMC,OAAO,mCACRV,0BADQ,GAERO,OAAO,CAACG,OAFA,CAAb,CAHkB,CAQlB;;;AACA,MAAMC,oBAAoB,GACxBC,KAAK,CAACC,OAAN,CAAcL,QAAd,KACA,eAAAA,QAAQ,CAAC,CAAD,CAAR,0DAAaC,IAAb,CAAkBK,MAAlB,MAA6B,OAD7B,oBAEAN,QAAQ,CAAC,CAAD,CAFR,gDAEA,YAAaC,IAAb,CAAkBM,EAFlB,KAGA,gBAAAP,QAAQ,CAAC,CAAD,CAAR,4DAAaC,IAAb,CAAkBM,EAAlB,KAAwBT,KAAK,CAACU,QAAN,CAAeR,QAJzC;;AAKA,MAAIG,oBAAJ,EAA0B;AACxB,WAAO,+BAAwB,CAC7B,4BAAM,UAAN,EACE,6BAAsBM,sCAAtB,EAAoD;AAClDT,MAAAA,QAAQ,EAARA,QADkD;AAElDE,MAAAA,OAAO,EAAPA,OAFkD;AAGlDZ,MAAAA,MAAM,EAANA;AAHkD,KAApD,CADF,CAD6B,CAAxB,EAQJQ,KARI,CAAP;AASD,GAxBiB,CA0BlB;;;AACA,MAAIY,YAA0B,GAAGpB,MAAjC;;AAEA,MAAID,aAAa,CAACC,MAAD,CAAjB,EAA2B;AACzB;AACA;AACAoB,IAAAA,YAAY,GAAGZ,KAAK,CAACU,QAAN,CAAeG,MAAf,CAAsBC,gBAAtB,CAAuCtB,MAAvC,CAAf;AACD;;AACD,MAAMuB,SAAS,GAAGf,KAAK,CAACU,QAAN,CAAeM,MAAjC;;AACA,MAAMC,sBAAsB,GAAG,SAAzBA,sBAAyB,CAACD,MAAD;AAAA,WAC7BA,MAAM,CAACE,MAAP,CAAc,UAAAC,EAAE;AAAA,aAAI,CAACJ,SAAS,CAACK,IAAV,CAAe,UAAAC,EAAE;AAAA,eAAIA,EAAE,KAAKF,EAAX;AAAA,OAAjB,CAAL;AAAA,KAAhB,CAD6B;AAAA,GAA/B,CAnCkB,CAsClB;;;AACA,MAAMG,uBAAuB,GAAG,SAA1BA,uBAA0B,CAACN,MAAD,EAAqB;AACnD,QAAMO,MAAM,GAAGnB,OAAO,CAACT,SAAR,IAAqB,8BAAcqB,MAAd,CAApC;AACA,WAAOO,MAAM,GAAGA,MAAH,GAAYC,SAAzB;AACD,GAHD;;AAKA,SAAO,+BAAwB,CAC7B,4BAAM,UAAN,EACE,6BAAsBb,sCAAtB,EAAoD;AAClDT,IAAAA,QAAQ,EAARA,QADkD;AAElDE,IAAAA,OAAO,EAAPA,OAFkD;AAGlDZ,IAAAA,MAAM,EAAEoB;AAH0C,GAApD,CADF,CAD6B,EAS7B,0BACEa,OAAO,CAACtB,IAAD,CADT,EAEE,4BAAM,UAAN,EACE,6BAAsBuB,mCAAtB,EAAyC;AAACvB,IAAAA,IAAI,EAAJA;AAAD,GAAzC,CADF,CAFF,CAT6B,EAe7B,4BAAM;AAAA,QAAEO,QAAF,SAAEA,QAAF;AAAA,WACJ,4BAAM,UAAN,EACE,6BACEiB,yCADF,EAEE,+BAAS;AACPnC,MAAAA,MAAM,EAAEoB,YADD;AAEPR,MAAAA,OAAO,EAAPA,OAFO;AAGPmB,MAAAA,MAAM,EAAED,uBAAuB,CAACL,sBAAsB,CAACP,QAAQ,CAACM,MAAV,CAAvB;AAHxB,KAAT,CAFF,CADF,CADI;AAAA,GAAN,CAf6B,EA2B7B,4BAAM,UAAN,EAAkB,6BAAOY,yCAAP,EAA8B,+BAAS;AAACpC,IAAAA,MAAM,EAAEoB,YAAT;AAAuBR,IAAAA,OAAO,EAAPA;AAAvB,GAAT,CAA9B,CAAlB,CA3B6B,EA4B7B,4BAAM,SAAN,EAAiB,6BAAOyB,wCAAP,EAAuC,+BAAS,IAAT,CAAvC,CAAjB,CA5B6B,EA6B7B,4BAAM,SAAN,EAAiB,6BAAOC,mCAAP,EAA2B,+BAAS,IAAT,CAA3B,CAAjB,CA7B6B,EA8B7B,4BAAM,SAAN,EAAiB,6BAAO1B,OAAO,CAAC2B,cAAR,CAAuB,UAAvB,IAAqC;AAACC,IAAAA,QAAQ,EAAE5B,OAAO,CAAC4B;AAAnB,GAArC,GAAoE,EAA3E,CAAjB,CA9B6B,CAAxB,EA+BJhC,KA/BI,CAAP;AAgCD,CA/EM;;;;AAiFA,IAAMiC,uBAAuB,GAAG,SAA1BA,uBAA0B,CACrCjC,KADqC,EAErCkC,MAFqC,EAGnB;AAClB;AACA,MAAMC,QAAQ,GAAG,oCAAmBD,MAAM,CAACE,MAA1B,CAAjB;AACA,MAAMC,SAAS,GAAG,+BAAS,CACzB,4BAAM,UAAN,EACE,6BAAO;AACLC,IAAAA,WAAW,EAAE,KADR;AAELC,IAAAA,mBAAmB,EAAE;AAFhB,GAAP,CADF,CADyB,CAAT,EAOfvC,KAPe,CAAlB,CAHkB,CAWlB;;AACA,MAAMwC,aAAa,GAAG,+BAASL,QAAQ,CAACM,GAAT,CAAa,UAAAC,CAAC;AAAA,WAAI,6BAAO3C,mBAAP,EAA4B,+BAAS2C,CAAT,CAA5B,CAAJ;AAAA,GAAd,CAAT,EACpBL,SADoB,CAAtB;AAGA,SAAOG,aAAP;AACD,CAnBM;;;AAqBA,IAAMG,oBAAoB,GAAG5C,mBAA7B;AAEP;AACA;AACA;AACA;;;;AACA,IAAM6C,qBAAqB,GAAG,SAAxBA,qBAAwB,CAAAC,eAAe;AAAA,SAAI,UAAAnC,QAAQ,EAAI;AAC3D,QAAIA,QAAQ,CAACmC,eAAT,KAA6BC,6BAAkBC,MAAlB,CAAyBC,KAA1D,EAAiE;AAC/D,6CACKtC,QADL;AAEEmC,QAAAA,eAAe,EAAfA;AAFF;AAID;;AACD,WAAOnC,QAAP;AACD,GAR4C;AAAA,CAA7C;AAUA;AACA;AACA;AACA;;;AACA,IAAMuC,uBAAuB,GAAG,SAA1BA,uBAA0B,CAC9BC,kBAD8B;AAAA,MAE9BC,OAF8B,uEAEL,IAFK;AAAA,SAG3B,UAAAzC,QAAQ;AAAA,2CACRA,QADQ;AAEXM,MAAAA,MAAM,EAAEN,QAAQ,CAACM,MAAT,CAAgByB,GAAhB,CAAoB,UAAAW,KAAK,EAAI;AACnC,YAAI,CAACD,OAAD,IAAYC,KAAK,CAAC3C,EAAN,KAAa0C,OAA7B,EAAsC;AACpC,cAAIC,KAAK,CAACC,iBAAN,CAAwBtB,cAAxB,CAAuC,oBAAvC,CAAJ,EAAkE;AAAA,gBACzDuB,SADyD,GAC5CF,KAAK,CAAC5D,MADsC,CACzD8D,SADyD;AAEhE,mBAAOF,KAAK,CAACG,iBAAN,CAAwB;AAC7BD,cAAAA,SAAS,kCAAMA,SAAN;AAAiBJ,gBAAAA,kBAAkB,EAAlBA;AAAjB;AADoB,aAAxB,CAAP;AAGD;AACF;;AACD,eAAOE,KAAP;AACD,OAVO;AAFG;AAAA,GAHmB;AAAA,CAAhC;AAkBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,IAAMI,6BAA6B,GAAG,SAAhCA,6BAAgC,CAC3CxD,KAD2C,EAE3CkC,MAF2C,EAGzB;AAAA,MACXjC,OADW,GACAiC,MADA,CACXjC,OADW;AAAA,MAEXwD,QAFW,GAECzD,KAFD,CAEXyD,QAFW;;AAGlB,MAAMC,YAAY,GAAG,SAAfA,YAAe,CAAAC,GAAG;AAAA;;AAAA,oCAAIF,QAAQ,CAACG,SAAT,CAAmBD,GAAnB,CAAJ,0DAAI,sBAAyBE,SAA7B;AAAA,GAAxB;;AACA,MAAMC,aAAa,GAAGJ,YAAY,CAACD,QAAQ,CAACM,SAAV,CAAlC;AACA,MAAMC,aAAa,GAAGN,YAAY,CAACzD,OAAO,CAAC8D,SAAT,CAAlC;AALkB,MAMbrD,QANa,GAMDV,KANC,CAMbU,QANa;;AAOlB,MAAIsD,aAAa,KAAKF,aAAtB,EAAqC;AACnC,YAAQE,aAAR;AACE,WAAKC,gCAAqBC,IAA1B;AACExD,QAAAA,QAAQ,GAAG,+BAAS,CAClBkC,qBAAqB,CAACE,6BAAkBqB,MAAlB,CAAyBnB,KAA1B,CADH,EAElBC,uBAAuB,CAAC,IAAD,CAFL,CAAT,EAGRvC,QAHQ,CAAX;AAIA;;AACF,WAAKuD,gCAAqBG,KAA1B;AACE1D,QAAAA,QAAQ,GAAG,+BAAS,CAClBkC,qBAAqB,CAACE,6BAAkBuB,MAAlB,CAAyBrB,KAA1B,CADH,EAElBC,uBAAuB,CAAC,KAAD,CAFL,CAAT,EAGRvC,QAHQ,CAAX;AAIA;;AACF,cAbF,CAcE;;AAdF;AAgBD;;AACD,yCACKV,KADL;AAEEU,IAAAA,QAAQ,EAARA,QAFF;AAGE+C,IAAAA,QAAQ,EAAE,6CAAsBA,QAAtB,EAAgC;AAACxD,MAAAA,OAAO,oBAAMA,OAAN;AAAR,KAAhC;AAHZ;AAKD,CAjCM;AAmCP;AACA;AACA;AACA;AACA;;;;;AACO,IAAMqE,8BAA8B,GAAG,SAAjCA,8BAAiC,CAC5CtE,KAD4C,EAE5CkC,MAF4C,EAG1B;AAAA,MACbxB,QADa,GACDV,KADC,CACbU,QADa;AAElB,MAAM6D,aAAa,GAAG7D,QAAQ,CAACM,MAAT,CAAgBwD,SAAhB,CAA0B,UAAApB,KAAK;AAAA,WAAIA,KAAK,KAAKlB,MAAM,CAACuC,QAArB;AAAA,GAA/B,CAAtB;AACA/D,EAAAA,QAAQ,GAAG,8CAAuBA,QAAvB,EAAiCwB,MAAjC,CAAX;AACA,MAAMwC,QAAQ,GAAGhE,QAAQ,CAACM,MAAT,CAAgBuD,aAAhB,CAAjB;;AACA,MAAIG,QAAJ,aAAIA,QAAJ,eAAIA,QAAQ,CAAErB,iBAAV,CAA4BtB,cAA5B,CAA2C,oBAA3C,CAAJ,EAAsE;AAAA,QAC7D0B,QAD6D,GACjDzD,KADiD,CAC7DyD,QAD6D;AAAA,QAE7DI,SAF6D,GAEhDJ,QAAQ,CAACG,SAAT,CAAmBH,QAAQ,CAACM,SAA5B,CAFgD,CAE7DF,SAF6D;AAAA,QAG7DX,kBAH6D,GAGvCwB,QAAQ,CAAClF,MAAT,CAAgB8D,SAHuB,CAG7DJ,kBAH6D;;AAIpE,YAAQW,SAAR;AACE,WAAKI,gCAAqBC,IAA1B;AACE,YAAI,CAAChB,kBAAL,EAAyB;AACvBxC,UAAAA,QAAQ,GAAGuC,uBAAuB,CAAC,IAAD,EAAOyB,QAAQ,CAACjE,EAAhB,CAAvB,CAA2CC,QAA3C,CAAX;AACD;;AACD;;AACF,WAAKuD,gCAAqBG,KAA1B;AACE,YAAIlB,kBAAJ,EAAwB;AACtBxC,UAAAA,QAAQ,GAAGuC,uBAAuB,CAAC,KAAD,EAAQyB,QAAQ,CAACjE,EAAjB,CAAvB,CAA4CC,QAA5C,CAAX;AACD;;AACD;;AACF,cAXF,CAYE;;AAZF;AAcD;;AACD,yCACKV,KADL;AAEEU,IAAAA,QAAQ,EAARA;AAFF;AAID,CA/BM;AAiCP;AACA;AACA;;;;;AACO,IAAMiE,qBAAqB,GAAG,SAAxBA,qBAAwB,CACnC3E,KADmC,EAEnCkC,MAFmC,EAGjB;AAAA;;AAClB,MAAM0C,QAAQ,mCACT5E,KADS;AAEZU,IAAAA,QAAQ,EAAE,6CAA8BV,KAAK,CAACU,QAApC,EAA8CwB,MAA9C,CAFE;AAGZ2C,IAAAA,OAAO,EAAE,4CAA6B7E,KAAK,CAAC6E,OAAnC,CAHG;AAIZC,IAAAA,QAAQ,EAAE,6CAA8B9E,KAAK,CAAC8E,QAApC,EAA8C5C,MAA9C;AAJE,IAAd;;AAOA,MAAM6C,OAAO,GAAGH,QAAQ,CAAClE,QAAT,CAAkBsE,SAAlB,CAA4BC,MAA5B,KAAuC,CAAvD;AACA,MAAMC,cAAc,4BAAGN,QAAQ,CAACC,OAAT,CAAiBM,WAApB,oFAAG,sBAA8BC,SAAjC,2DAAG,uBAAyCC,MAAhE;;AACA,MAAIN,OAAO,IAAI,CAACG,cAAhB,EAAgC;AAC9BN,IAAAA,QAAQ,CAACC,OAAT,GAAmB,8CAAwBD,QAAQ,CAACC,OAAjC,EAA0C;AAC3D5E,MAAAA,OAAO,EAAE;AAACqF,QAAAA,OAAO,EAAE,WAAV;AAAuBC,QAAAA,KAAK,EAAErD,MAAM,CAACjC;AAArC;AADkD,KAA1C,CAAnB;AAGD;;AAED,SAAO2E,QAAP;AACD,CApBM;;;AAsBP,IAAMY,8BAA8B,GAAG;AACrC5F,EAAAA,kBAAkB,EAAE,IADiB;AAErCD,EAAAA,SAAS,EAAE,IAF0B;AAGrCE,EAAAA,gBAAgB,EAAE;AAHmB,CAAvC;AAMA;AACA;AACA;;AACO,IAAM4F,uBAAuB,GAAG,SAA1BA,uBAA0B,CACrCzF,KADqC,SAGnB;AAAA,MADjBC,OACiB,SADjBA,OACiB;AAAA,MACXyF,kBADW,GACuCzF,OADvC,CACXyF,kBADW;AAAA,MACSC,YADT,GACuC1F,OADvC,CACS0F,YADT;AAAA,yBACuC1F,OADvC,CACuBG,OADvB;AAAA,MACuBA,OADvB,iCACiC,EADjC;;AAElB,MAAMwF,mBAAmB,mCAAOJ,8BAAP,GAA0CpF,OAA1C,CAAzB,CAFkB,CAIlB;;;AACA,MAAI,CAACJ,KAAK,CAACU,QAAN,CAAeR,QAAf,CAAwBwF,kBAAxB,CAAL,EAAkD;AAChD,WAAO1F,KAAP;AACD,GAPiB,CAQlB;;;AACA,MAAM6F,WAAW,GAAGF,YAAY,CAACxF,IAAb,CAAkBM,EAAtC;;AACA,MAAI,CAACoF,WAAL,EAAkB;AAChB,WAAO7F,KAAP;AACD,GAZiB,CAalB;;;AACA,MAAM8F,aAAa,mCACd9F,KADc;AAEjBU,IAAAA,QAAQ,EAAE,qDAA8BV,KAAK,CAACU,QAApC,EAA8CgF,kBAA9C,EAAkEG,WAAlE;AAFO,IAAnB;;AAKA,MAAMxD,SAAS,GAAGtC,mBAAmB,CACnC+F,aADmC,EAEnC,+BAAS;AACP5F,IAAAA,QAAQ,EAAEyF,YADH;AAEP;AACAvF,IAAAA,OAAO,EAAEwF;AAHF,GAAT,CAFmC,CAArC;AASA,SAAOvD,SAAP;AACD,CAhCM","sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {\n  toggleModalUpdater,\n  loadFilesSuccessUpdater as uiStateLoadFilesSuccessUpdater,\n  toggleMapControlUpdater,\n  toggleSplitMapUpdater as uiStateToggleSplitMapUpdater\n} from './ui-state-updaters';\nimport {\n  updateVisDataUpdater as visStateUpdateVisDataUpdater,\n  setMapInfoUpdater,\n  layerTypeChangeUpdater,\n  toggleSplitMapUpdater as visStateToggleSplitMapUpdater,\n  prepareStateForDatasetReplace\n} from './vis-state-updaters';\nimport {\n  receiveMapConfigUpdater as stateMapConfigUpdater,\n  toggleSplitMapUpdater as mapStateToggleSplitMapUpdater\n} from './map-state-updaters';\nimport {\n  mapStyleChangeUpdater,\n  receiveMapConfigUpdater as styleMapConfigUpdater\n} from './map-style-updaters';\nimport {filesToDataPayload} from '@kepler.gl/processors';\nimport {payload_, apply_, with_, if_, compose_, merge_, pick_} from './composer-helpers';\nimport {MapState, UiState, AddDataToMapPayload, ParsedConfig} from '@kepler.gl/types';\nimport {MapStyle} from './map-style-updaters';\nimport {ProviderState} from './provider-state-updaters';\nimport {\n  loadFilesSuccessUpdaterAction,\n  MapStyleChangeUpdaterAction,\n  LayerTypeChangeUpdaterAction,\n  ToggleSplitMapUpdaterAction,\n  ReplaceDataInMapPayload\n} from '@kepler.gl/actions';\nimport {VisState} from '@kepler.gl/schemas';\nimport {Layer} from '@kepler.gl/layers';\nimport {isPlainObject} from '@kepler.gl/utils';\nimport {findMapBounds} from './data-utils';\nimport {BASE_MAP_COLOR_MODES, OVERLAY_BLENDINGS} from '@kepler.gl/constants';\n\nexport type KeplerGlState = {\n  visState: VisState;\n  mapState: MapState;\n  mapStyle: MapStyle;\n  uiState: UiState;\n  providerState: ProviderState;\n};\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  autoCreateTooltips: 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 * @public\n */\nexport const addDataToMapUpdater = (\n  state: KeplerGlState,\n  {payload}: {payload: AddDataToMapPayload}\n): KeplerGlState => {\n  const {datasets, config, info} = payload;\n\n  const options = {\n    ...defaultAddDataToMapOptions,\n    ...payload.options\n  };\n\n  // check if progresive loading dataset by bataches, and update visState directly\n  const isProgressiveLoading =\n    Array.isArray(datasets) &&\n    datasets[0]?.info.format === 'arrow' &&\n    datasets[0]?.info.id &&\n    datasets[0]?.info.id in state.visState.datasets;\n  if (isProgressiveLoading) {\n    return compose_<KeplerGlState>([\n      pick_('visState')(\n        apply_<VisState, any>(visStateUpdateVisDataUpdater, {\n          datasets,\n          options,\n          config\n        })\n      )\n    ])(state);\n  }\n\n  // @ts-expect-error\n  let parsedConfig: ParsedConfig = config;\n\n  if (isValidConfig(config)) {\n    // if passed in saved config\n    // @ts-expect-error\n    parsedConfig = state.visState.schema.parseSavedConfig(config);\n  }\n  const oldLayers = state.visState.layers;\n  const filterNewlyAddedLayers = (layers: Layer[]) =>\n    layers.filter(nl => !oldLayers.find(ol => ol === nl));\n\n  // Returns undefined if not found, to make typescript happy\n  const findMapBoundsIfCentered = (layers: Layer[]) => {\n    const bounds = options.centerMap && findMapBounds(layers);\n    return bounds ? bounds : undefined;\n  };\n\n  return compose_<KeplerGlState>([\n    pick_('visState')(\n      apply_<VisState, any>(visStateUpdateVisDataUpdater, {\n        datasets,\n        options,\n        config: parsedConfig\n      })\n    ),\n\n    if_(\n      Boolean(info),\n      pick_('visState')(\n        apply_<VisState, any>(setMapInfoUpdater, {info})\n      )\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    pick_('mapStyle')(apply_(styleMapConfigUpdater, payload_({config: parsedConfig, options}))),\n    pick_('uiState')(apply_(uiStateLoadFilesSuccessUpdater, payload_(null))),\n    pick_('uiState')(apply_(toggleModalUpdater, payload_(null))),\n    pick_('uiState')(merge_(options.hasOwnProperty('readOnly') ? {readOnly: options.readOnly} : {}))\n  ])(state);\n};\n\nexport const loadFilesSuccessUpdater = (\n  state: KeplerGlState,\n  action: loadFilesSuccessUpdaterAction\n): KeplerGlState => {\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 as KeplerGlState;\n};\n\nexport const addDataToMapComposed = addDataToMapUpdater;\n\n/**\n * Helper which updates map overlay blending mode in visState,\n * but only if it's not currently in the `normal` mode.\n */\nconst updateOverlayBlending = overlayBlending => visState => {\n  if (visState.overlayBlending !== OVERLAY_BLENDINGS.normal.value) {\n    return {\n      ...visState,\n      overlayBlending\n    };\n  }\n  return visState;\n};\n\n/**\n * Helper which updates `darkBaseMapEnabled` in all the layers in visState which\n * have this config setting (or in one specific layer if the `layerId` param is provided).\n */\nconst updateDarkBaseMapLayers = (\n  darkBaseMapEnabled: boolean,\n  layerId: string | null = null\n) => visState => ({\n  ...visState,\n  layers: visState.layers.map(layer => {\n    if (!layerId || layer.id === layerId) {\n      if (layer.visConfigSettings.hasOwnProperty('darkBaseMapEnabled')) {\n        const {visConfig} = layer.config;\n        return layer.updateLayerConfig({\n          visConfig: {...visConfig, darkBaseMapEnabled}\n        });\n      }\n    }\n    return layer;\n  })\n});\n\n/**\n * Updater that changes the map style by calling mapStyleChangeUpdater on visState.\n * In addition to that, it does the following:\n *\n *   1. Update map overlay blending mode in accordance with the colorMode of the\n *      base map, but only if it's not in the `normal` mode.\n *\n *   2. Update all the layers which have the `darkBaseMapEnabled` config setting\n *      adjusting it in accordance with the colorMode of the base map.\n *\n */\nexport const combinedMapStyleChangeUpdater = (\n  state: KeplerGlState,\n  action: MapStyleChangeUpdaterAction\n): KeplerGlState => {\n  const {payload} = action;\n  const {mapStyle} = state;\n  const getColorMode = key => mapStyle.mapStyles[key]?.colorMode;\n  const prevColorMode = getColorMode(mapStyle.styleType);\n  const nextColorMode = getColorMode(payload.styleType);\n  let {visState} = state;\n  if (nextColorMode !== prevColorMode) {\n    switch (nextColorMode) {\n      case BASE_MAP_COLOR_MODES.DARK:\n        visState = compose_([\n          updateOverlayBlending(OVERLAY_BLENDINGS.screen.value),\n          updateDarkBaseMapLayers(true)\n        ])(visState);\n        break;\n      case BASE_MAP_COLOR_MODES.LIGHT:\n        visState = compose_([\n          updateOverlayBlending(OVERLAY_BLENDINGS.darken.value),\n          updateDarkBaseMapLayers(false)\n        ])(visState);\n        break;\n      default:\n      // do nothing\n    }\n  }\n  return {\n    ...state,\n    visState,\n    mapStyle: mapStyleChangeUpdater(mapStyle, {payload: {...payload}})\n  };\n};\n\n/**\n * Updater that changes the layer type by calling `layerTypeChangeUpdater` on visState.\n * In addition to that, if the new layer type has the `darkBaseMapEnabled` config\n * setting, we adjust it in accordance with the colorMode of the base map.s\n */\nexport const combinedLayerTypeChangeUpdater = (\n  state: KeplerGlState,\n  action: LayerTypeChangeUpdaterAction\n): KeplerGlState => {\n  let {visState} = state;\n  const oldLayerIndex = visState.layers.findIndex(layer => layer === action.oldLayer);\n  visState = layerTypeChangeUpdater(visState, action);\n  const newLayer = visState.layers[oldLayerIndex];\n  if (newLayer?.visConfigSettings.hasOwnProperty('darkBaseMapEnabled')) {\n    const {mapStyle} = state;\n    const {colorMode} = mapStyle.mapStyles[mapStyle.styleType];\n    const {darkBaseMapEnabled} = newLayer.config.visConfig;\n    switch (colorMode) {\n      case BASE_MAP_COLOR_MODES.DARK:\n        if (!darkBaseMapEnabled) {\n          visState = updateDarkBaseMapLayers(true, newLayer.id)(visState);\n        }\n        break;\n      case BASE_MAP_COLOR_MODES.LIGHT:\n        if (darkBaseMapEnabled) {\n          visState = updateDarkBaseMapLayers(false, newLayer.id)(visState);\n        }\n        break;\n      default:\n      // do nothing\n    }\n  }\n  return {\n    ...state,\n    visState\n  };\n};\n\n/**\n * Make mapLegend active when toggleSplitMap action is called\n */\nexport const toggleSplitMapUpdater = (\n  state: KeplerGlState,\n  action: ToggleSplitMapUpdaterAction\n): KeplerGlState => {\n  const newState = {\n    ...state,\n    visState: visStateToggleSplitMapUpdater(state.visState, action),\n    uiState: uiStateToggleSplitMapUpdater(state.uiState),\n    mapState: mapStateToggleSplitMapUpdater(state.mapState, action)\n  };\n\n  const isSplit = newState.visState.splitMaps.length !== 0;\n  const isLegendActive = newState.uiState.mapControls?.mapLegend?.active;\n  if (isSplit && !isLegendActive) {\n    newState.uiState = toggleMapControlUpdater(newState.uiState, {\n      payload: {panelId: 'mapLegend', index: action.payload}\n    });\n  }\n\n  return newState;\n};\n\nconst defaultReplaceDataToMapOptions = {\n  keepExistingConfig: true,\n  centerMap: true,\n  autoCreateLayers: false\n};\n\n/**\n * Updater replace a dataset in state\n */\nexport const replaceDataInMapUpdater = (\n  state: KeplerGlState,\n  {payload}: {payload: ReplaceDataInMapPayload}\n): KeplerGlState => {\n  const {datasetToReplaceId, datasetToUse, options = {}} = payload;\n  const addDataToMapOptions = {...defaultReplaceDataToMapOptions, ...options};\n\n  // check if dataset is there\n  if (!state.visState.datasets[datasetToReplaceId]) {\n    return state;\n  }\n  // datasetToUse is ProtoDataset\n  const dataIdToUse = datasetToUse.info.id;\n  if (!dataIdToUse) {\n    return state;\n  }\n  // remove dataset and put dependencies in toBeMerged\n  const preparedState = {\n    ...state,\n    visState: prepareStateForDatasetReplace(state.visState, datasetToReplaceId, dataIdToUse)\n  };\n\n  const nextState = addDataToMapUpdater(\n    preparedState,\n    payload_({\n      datasets: datasetToUse,\n      // should zoom to new dataset\n      options: addDataToMapOptions\n    })\n  );\n\n  return nextState;\n};\n"]}

package/dist/composer-helpers.d.ts

@@ -6,7 +6,8 @@ export declare function payload_<P>(payload: P): {
 };
 /** Wraps a value in an object and stores it the `payload` field */
 export declare function apply_<State, P>(updater: (state: State, nextPayload: P) => State, payload: P): (state: State) => State;
-export declare function with_<State>(fn: (state: State) => (nextState: State) => State): (state: State) => State;
+declare type Arg<State> = (state: State) => (nextState: State) => State;
+export declare function with_<State>(fn: Arg<State>): (state: State) => State;
 export declare function if_<State>(pred: boolean, fn: (state: State) => State): (state: State) => State;
 export declare function compose_<State>(fns: Array<(s: State) => State>): (s: State) => State;
 /** Returns a reducer function that merges props with state */
@@ -15,7 +16,9 @@ export declare function pick_<Prop extends string>(prop: Prop): <Value>(fn: (p:
 export declare function swap_<X extends {
     id: string;
 }>(item: X): (arr: X[]) => X[];
-export declare function findById<X extends {
+export declare function map_<X, T>(fn: (state: X) => T): (arr: X[]) => T[];
+export declare function filterOutById<X extends {
     id: string;
-}>(id: string): (arr: X[]) => X | undefined;
-export declare function map_<X>(fn: (state: X) => X): (arr: X[]) => X[];
+}>(id: string): (arr: X[]) => X[];
+export declare function removeElementAtIndex<X>(index: number): (arr: X[]) => X[];
+export {};

package/dist/composer-helpers.js

@@ -1,23 +1,3 @@
-// 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.
-
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
@@ -34,8 +14,11 @@ exports.compose_ = compose_;
 exports.merge_ = merge_;
 exports.pick_ = pick_;
 exports.swap_ = swap_;
-exports.findById = findById;
 exports.map_ = map_;
+exports.filterOutById = filterOutById;
+exports.removeElementAtIndex = removeElementAtIndex;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
@@ -115,19 +98,25 @@ function swap_(item) {
   };
 }
 
-function findById(id) {
+function map_(fn) {
   return function (arr) {
-    return arr.find(function (a) {
-      return a.id === id;
+    return arr.map(function (e) {
+      return fn(e);
     });
   };
 }
 
-function map_(fn) {
+function filterOutById(id) {
   return function (arr) {
-    return arr.map(function (e) {
-      return fn(e);
+    return arr.filter(function (e) {
+      return e.id !== id;
     });
   };
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+
+function removeElementAtIndex(index) {
+  return function (arr) {
+    return [].concat((0, _toConsumableArray2["default"])(arr.slice(0, index)), (0, _toConsumableArray2["default"])(arr.slice(index + 1, arr.length)));
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/composers.d.ts

@@ -7,6 +7,12 @@ declare const actionHandler: {
     "@@kepler.gl/ADD_DATA_TO_MAP": (state: combinedUpdaters.KeplerGlState, { payload }: {
         payload: import("@kepler.gl/types").AddDataToMapPayload;
     }) => combinedUpdaters.KeplerGlState;
+    "@@kepler.gl/MAP_STYLE_CHANGE": (state: combinedUpdaters.KeplerGlState, action: import("@kepler.gl/actions").MapStyleChangeUpdaterAction) => combinedUpdaters.KeplerGlState;
+    "@@kepler.gl/LAYER_TYPE_CHANGE": (state: combinedUpdaters.KeplerGlState, action: import("@kepler.gl/actions").LayerTypeChangeUpdaterAction) => combinedUpdaters.KeplerGlState;
     "@@kepler.gl/LOAD_FILES_SUCCESS": (state: combinedUpdaters.KeplerGlState, action: import("@kepler.gl/actions").loadFilesSuccessUpdaterAction) => combinedUpdaters.KeplerGlState;
+    "@@kepler.gl/TOGGLE_SPLIT_MAP": (state: combinedUpdaters.KeplerGlState, action: import("@kepler.gl/actions").ToggleSplitMapUpdaterAction) => combinedUpdaters.KeplerGlState;
+    "@@kepler.gl/REPLACE_DATA_IN_MAP": (state: combinedUpdaters.KeplerGlState, { payload }: {
+        payload: import("@kepler.gl/actions").ReplaceDataInMapPayload;
+    }) => combinedUpdaters.KeplerGlState;
 };
 export default actionHandler;

package/dist/composers.js

@@ -1,23 +1,3 @@
-// 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.
-
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
@@ -41,7 +21,7 @@ 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, _actions.ActionTypes.ADD_DATA_TO_MAP, combinedUpdaters.addDataToMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.LOAD_FILES_SUCCESS, combinedUpdaters.loadFilesSuccessUpdater), _actionHandler);
+var actionHandler = (_actionHandler = {}, (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.ADD_DATA_TO_MAP, combinedUpdaters.addDataToMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.MAP_STYLE_CHANGE, combinedUpdaters.combinedMapStyleChangeUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.LAYER_TYPE_CHANGE, combinedUpdaters.combinedLayerTypeChangeUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.LOAD_FILES_SUCCESS, combinedUpdaters.loadFilesSuccessUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_SPLIT_MAP, combinedUpdaters.toggleSplitMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.REPLACE_DATA_IN_MAP, combinedUpdaters.replaceDataInMapUpdater), _actionHandler);
 var _default = actionHandler;
 exports["default"] = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/core.d.ts

@@ -9,7 +9,7 @@ export declare type KeplerGlState = {
     uiState: UiState;
     providerState: ProviderState;
 };
-export declare const coreReducerFactory: (initialState?: Partial<KeplerGlState>) => (state: any, action: any) => any;
+export declare const coreReducerFactory: (initialState?: Partial<KeplerGlState>, extraReducers?: {}) => (state: any, action: any) => any;
 declare const _default: (state: any, action: any) => any;
 export default _default;
 /**