@kepler.gl/reducers 3.3.0-alpha.5 → 3.3.0-alpha.7

package/dist/esm/combined-updaters.js

@@ -0,0 +1,484 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { toggleModalUpdater, loadFilesSuccessUpdater as uiStateLoadFilesSuccessUpdater, toggleMapControlUpdater, toggleSplitMapUpdater as uiStateToggleSplitMapUpdater, receiveMapConfigUpdater as uiStateReceiveMapConfigUpdater } from './ui-state-updaters';
+import { updateVisDataUpdater as visStateUpdateVisDataUpdater, setMapInfoUpdater, layerTypeChangeUpdater, toggleSplitMapUpdater as visStateToggleSplitMapUpdater, prepareStateForDatasetReplace } from './vis-state-updaters';
+import { receiveMapConfigUpdater as stateMapConfigUpdater, toggleSplitMapUpdater as mapStateToggleSplitMapUpdater, setMapSplitModeUpdater as mapStateSetMapSplitModeUpdater, setMapViewModeUpdater } from './map-state-updaters';
+import { mapStyleChangeUpdater, receiveMapConfigUpdater as styleMapConfigUpdater } from './map-style-updaters';
+import { filesToDataPayload } from '@kepler.gl/processors';
+import { payload_, apply_, with_, if_, compose_, merge_, pick_ } from './composer-helpers';
+import { isPlainObject, computeSplitMapLayers } from '@kepler.gl/utils';
+import { findMapBounds } from './data-utils';
+import { BASE_MAP_COLOR_MODES, OVERLAY_BLENDINGS, NO_MAP_ID, MapSplitMode } from '@kepler.gl/constants';
+import { getBasemapColorsForStyle, DEFAULT_BASEMAP_COLOR } from '@kepler.gl/deckgl-layers';
+// 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 @typescript-eslint/no-unused-vars */
+// @ts-ignore
+var combinedUpdaters = null;
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
+export var isValidConfig = function isValidConfig(config) {
+  return isPlainObject(config) && isPlainObject(config.config) && config.version;
+};
+export var defaultAddDataToMapOptions = {
+  centerMap: true,
+  keepExistingConfig: false,
+  autoCreateLayers: true,
+  autoCreateTooltips: 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, padding: {left: 300}}`
+ * @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`
+ *
+ * @public
+ */
+export 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);
+
+  // check if progressive loading dataset by batches, 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 compose_([pick_('visState')(apply_(visStateUpdateVisDataUpdater, {
+      datasets: datasets,
+      options: options,
+      config: config
+    }))])(state);
+  }
+
+  // @ts-expect-error
+  var parsedConfig = config;
+  if (isValidConfig(config)) {
+    // if passed in saved config
+    // @ts-expect-error
+    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 && findMapBounds(layers);
+    return bounds ? bounds : undefined;
+  };
+  return compose_([pick_('visState')(
+  // this part can be async
+  apply_(visStateUpdateVisDataUpdater, {
+    datasets: datasets,
+    options: options,
+    config: parsedConfig
+  })), if_(Boolean(info), pick_('visState')(apply_(setMapInfoUpdater, {
+    info: info
+  }))),
+  // Note that fit bounds here won't be called in case datasets are created in Tasks.
+  // A separate Task to update bounds is created once the datasets are ready.
+  with_(function (_ref2) {
+    var visState = _ref2.visState;
+    return pick_('mapState')(apply_(stateMapConfigUpdater, payload_({
+      config: parsedConfig,
+      options: options,
+      bounds: findMapBoundsIfCentered(filterNewlyAddedLayers(visState.layers))
+    })));
+  }), pick_('mapStyle')(apply_(styleMapConfigUpdater, payload_({
+    config: parsedConfig,
+    options: options
+  }))), pick_('uiState')(apply_(uiStateReceiveMapConfigUpdater, payload_({
+    config: parsedConfig,
+    options: options
+  }))), pick_('uiState')(apply_(uiStateLoadFilesSuccessUpdater, payload_(null))), pick_('uiState')(apply_(toggleModalUpdater, payload_(null))), pick_('uiState')(merge_(Object.prototype.hasOwnProperty.call(options, 'readOnly') ? {
+    readOnly: options.readOnly
+  } : {}))])(state);
+};
+export var loadFilesSuccessUpdater = function loadFilesSuccessUpdater(state, action) {
+  // still more to load
+  var payloads = filesToDataPayload(action.result);
+  var nextState = compose_([pick_('visState')(merge_({
+    fileLoading: false,
+    fileLoadingProgress: {}
+  }))])(state);
+  // make multiple add data to map calls
+  var stateWithData = compose_(payloads.map(function (p) {
+    return apply_(addDataToMapUpdater, payload_(p));
+  }))(nextState);
+  return stateWithData;
+};
+export var addDataToMapComposed = addDataToMapUpdater;
+
+/**
+ * Helper which updates map overlay blending mode in visState,
+ * but only if it's not currently in the `normal` mode.
+ */
+var updateOverlayBlending = function updateOverlayBlending(overlayBlending) {
+  return function (visState) {
+    if (visState.overlayBlending !== 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 (Object.prototype.hasOwnProperty.call(layer.visConfigSettings, '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.
+ *
+ */
+export var combinedMapStyleChangeUpdater = function combinedMapStyleChangeUpdater(state, action) {
+  var _mapState$globe;
+  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,
+    mapState = state.mapState;
+  if (nextColorMode !== prevColorMode) {
+    switch (nextColorMode) {
+      case BASE_MAP_COLOR_MODES.DARK:
+        visState = compose_([updateOverlayBlending(OVERLAY_BLENDINGS.screen.value), updateDarkBaseMapLayers(true)])(visState);
+        break;
+      case BASE_MAP_COLOR_MODES.LIGHT:
+        visState = compose_([updateOverlayBlending(OVERLAY_BLENDINGS.darken.value), updateDarkBaseMapLayers(false)])(visState);
+        break;
+      default:
+      // do nothing
+    }
+  }
+
+  // Update globe config colors when style changes and globe is enabled
+  if ((_mapState$globe = mapState.globe) !== null && _mapState$globe !== void 0 && _mapState$globe.enabled) {
+    // Switching from "No Basemap" to a basemap - restore basemap sub-toggles
+    if (payload.styleType !== NO_MAP_ID && mapStyle.styleType === NO_MAP_ID) {
+      mapState = _objectSpread(_objectSpread({}, mapState), {}, {
+        globe: _objectSpread(_objectSpread({}, mapState.globe), {}, {
+          config: _objectSpread(_objectSpread({}, mapState.globe.config), {}, {
+            basemap: true,
+            labels: true,
+            adminLines: true,
+            water: true
+          })
+        })
+      });
+    }
+    mapState = syncGlobeConfigColorsToStyle(mapState, mapStyle, payload.styleType);
+  }
+  return _objectSpread(_objectSpread({}, state), {}, {
+    visState: visState,
+    mapState: mapState,
+    mapStyle: mapStyleChangeUpdater(mapStyle, {
+      payload: _objectSpread({}, payload)
+    })
+  });
+};
+
+/**
+ * Derive globe basemap colors (surface / water / admin lines) from a map style and
+ * return an updated mapState with those colors written into `globe.config`. Used both
+ * when the base map style changes and when entering globe mode, so the globe always
+ * reflects the currently selected basemap instead of the static DEFAULT_GLOBE_CONFIG.
+ */
+export function syncGlobeConfigColorsToStyle(mapState, mapStyle, styleType) {
+  var _mapState$globe2;
+  if (!((_mapState$globe2 = mapState.globe) !== null && _mapState$globe2 !== void 0 && _mapState$globe2.enabled)) {
+    return mapState;
+  }
+  var nextStyleObj = mapStyle.mapStyles[styleType];
+  var nextGlobeConfig = _objectSpread({}, mapState.globe.config);
+  if (styleType === NO_MAP_ID) {
+    nextGlobeConfig.basemap = false;
+    nextGlobeConfig.labels = false;
+    nextGlobeConfig.adminLines = false;
+    nextGlobeConfig.water = false;
+    nextGlobeConfig.surfaceColor = DEFAULT_BASEMAP_COLOR.backgroundFillColor;
+    nextGlobeConfig.waterColor = DEFAULT_BASEMAP_COLOR.basemapWaterFillColor;
+    nextGlobeConfig.adminLinesColor = DEFAULT_BASEMAP_COLOR.basemapAdminLineColor;
+  } else {
+    var basemapColors = nextStyleObj ? getBasemapColorsForStyle(styleType, {
+      style: nextStyleObj.style,
+      layerGroups: nextStyleObj.layerGroups
+    }) :
+    // Style object not yet loaded - use known presets by style type
+    getBasemapColorsForStyle(styleType);
+    nextGlobeConfig.surfaceColor = basemapColors.backgroundFillColor;
+    nextGlobeConfig.waterColor = basemapColors.basemapWaterFillColor;
+    nextGlobeConfig.adminLinesColor = basemapColors.basemapAdminLineColor;
+  }
+  return _objectSpread(_objectSpread({}, mapState), {}, {
+    globe: _objectSpread(_objectSpread({}, mapState.globe), {}, {
+      config: nextGlobeConfig
+    })
+  });
+}
+
+/**
+ * Updater that switches the map view mode (2D / 3D / Globe). Runs the base map-state
+ * updater and, when entering globe mode, syncs the globe basemap colors to the
+ * currently selected map style so the globe doesn't show stale default colors.
+ */
+export var combinedSetMapViewModeUpdater = function combinedSetMapViewModeUpdater(state, action) {
+  var _mapState$globe3;
+  var mapState = setMapViewModeUpdater(state.mapState, action);
+  if ((_mapState$globe3 = mapState.globe) !== null && _mapState$globe3 !== void 0 && _mapState$globe3.enabled) {
+    mapState = syncGlobeConfigColorsToStyle(mapState, state.mapStyle, state.mapStyle.styleType);
+  }
+  return _objectSpread(_objectSpread({}, state), {}, {
+    mapState: mapState
+  });
+};
+
+/**
+ * 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 var combinedLayerTypeChangeUpdater = function combinedLayerTypeChangeUpdater(state, action) {
+  var visState = state.visState;
+  var oldLayerIndex = visState.layers.findIndex(function (layer) {
+    return layer === action.oldLayer;
+  });
+  visState = layerTypeChangeUpdater(visState, action);
+  var newLayer = visState.layers[oldLayerIndex];
+  if (Object.prototype.hasOwnProperty.call(newLayer === null || newLayer === void 0 ? void 0 : newLayer.visConfigSettings, 'darkBaseMapEnabled')) {
+    var mapStyle = state.mapStyle;
+    var colorMode = mapStyle.mapStyles[mapStyle.styleType].colorMode;
+    var darkBaseMapEnabled = newLayer.config.visConfig.darkBaseMapEnabled;
+    switch (colorMode) {
+      case BASE_MAP_COLOR_MODES.DARK:
+        if (!darkBaseMapEnabled) {
+          visState = updateDarkBaseMapLayers(true, newLayer.id)(visState);
+        }
+        break;
+      case 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
+ */
+export var toggleSplitMapUpdater = function toggleSplitMapUpdater(state, action) {
+  var _newState$uiState$map;
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    visState: visStateToggleSplitMapUpdater(state.visState, action),
+    uiState: uiStateToggleSplitMapUpdater(state.uiState),
+    mapState: mapStateToggleSplitMapUpdater(state.mapState)
+  });
+  var isSplit = newState.visState.splitMaps.length !== 0;
+  var isLegendActive = (_newState$uiState$map = newState.uiState.mapControls) === null || _newState$uiState$map === void 0 || (_newState$uiState$map = _newState$uiState$map.mapLegend) === null || _newState$uiState$map === void 0 ? void 0 : _newState$uiState$map.active;
+  if (isSplit && !isLegendActive) {
+    newState.uiState = toggleMapControlUpdater(newState.uiState, {
+      payload: {
+        panelId: 'mapLegend',
+        index: action.payload
+      }
+    });
+  }
+  return newState;
+};
+
+/**
+ * Set map split mode updater - coordinates state changes across visState, mapState, and uiState
+ */
+export var setMapSplitModeUpdater = function setMapSplitModeUpdater(state, action) {
+  var _newUiState$mapContro;
+  var mapSplitMode = action.payload.mapSplitMode;
+  var prevMode = state.mapState.mapSplitMode;
+  if (mapSplitMode === prevMode) {
+    return state;
+  }
+  var newMapState = mapStateSetMapSplitModeUpdater(state.mapState, action);
+  var newVisState = _objectSpread({}, state.visState);
+  switch (mapSplitMode) {
+    case MapSplitMode.SINGLE_MAP:
+      newVisState = _objectSpread(_objectSpread({}, newVisState), {}, {
+        splitMaps: []
+      });
+      break;
+    case MapSplitMode.DUAL_MAP:
+    case MapSplitMode.SWIPE_COMPARE:
+      if (prevMode === MapSplitMode.SINGLE_MAP) {
+        newVisState = _objectSpread(_objectSpread({}, newVisState), {}, {
+          splitMaps: computeSplitMapLayers(newVisState.layers, {
+            duplicate: mapSplitMode === MapSplitMode.SWIPE_COMPARE
+          })
+        });
+      }
+      break;
+    default:
+      break;
+  }
+  var newUiState = uiStateToggleSplitMapUpdater(state.uiState);
+  var isSplit = newVisState.splitMaps.length !== 0;
+  var isLegendActive = (_newUiState$mapContro = newUiState.mapControls) === null || _newUiState$mapContro === void 0 || (_newUiState$mapContro = _newUiState$mapContro.mapLegend) === null || _newUiState$mapContro === void 0 ? void 0 : _newUiState$mapContro.active;
+  if (isSplit && !isLegendActive) {
+    newUiState = toggleMapControlUpdater(newUiState, {
+      payload: {
+        panelId: 'mapLegend',
+        index: 0
+      }
+    });
+  }
+  return _objectSpread(_objectSpread({}, state), {}, {
+    mapState: newMapState,
+    visState: newVisState,
+    uiState: newUiState
+  });
+};
+var defaultReplaceDataToMapOptions = {
+  keepExistingConfig: true,
+  centerMap: true,
+  autoCreateLayers: false
+};
+
+/**
+ * Updater replace a dataset in state
+ */
+export 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: prepareStateForDatasetReplace(state.visState, datasetToReplaceId, dataIdToUse)
+  });
+  var nextState = addDataToMapUpdater(preparedState, payload_({
+    datasets: datasetToUse,
+    // should zoom to new dataset
+    options: addDataToMapOptions
+  }));
+  return nextState;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["toggleModalUpdater","loadFilesSuccessUpdater","uiStateLoadFilesSuccessUpdater","toggleMapControlUpdater","toggleSplitMapUpdater","uiStateToggleSplitMapUpdater","receiveMapConfigUpdater","uiStateReceiveMapConfigUpdater","updateVisDataUpdater","visStateUpdateVisDataUpdater","setMapInfoUpdater","layerTypeChangeUpdater","visStateToggleSplitMapUpdater","prepareStateForDatasetReplace","stateMapConfigUpdater","mapStateToggleSplitMapUpdater","setMapSplitModeUpdater","mapStateSetMapSplitModeUpdater","setMapViewModeUpdater","mapStyleChangeUpdater","styleMapConfigUpdater","filesToDataPayload","payload_","apply_","with_","if_","compose_","merge_","pick_","isPlainObject","computeSplitMapLayers","findMapBounds","BASE_MAP_COLOR_MODES","OVERLAY_BLENDINGS","NO_MAP_ID","MapSplitMode","getBasemapColorsForStyle","DEFAULT_BASEMAP_COLOR","combinedUpdaters","isValidConfig","config","version","defaultAddDataToMapOptions","centerMap","keepExistingConfig","autoCreateLayers","autoCreateTooltips","addDataToMapUpdater","state","_ref","_datasets$","_datasets$2","_datasets$3","payload","datasets","info","options","_objectSpread","isProgressiveLoading","Array","isArray","format","id","visState","parsedConfig","schema","parseSavedConfig","oldLayers","layers","filterNewlyAddedLayers","filter","nl","find","ol","findMapBoundsIfCentered","bounds","undefined","Boolean","_ref2","Object","prototype","hasOwnProperty","call","readOnly","action","payloads","result","nextState","fileLoading","fileLoadingProgress","stateWithData","map","p","addDataToMapComposed","updateOverlayBlending","overlayBlending","normal","value","updateDarkBaseMapLayers","darkBaseMapEnabled","layerId","arguments","length","layer","visConfigSettings","visConfig","updateLayerConfig","combinedMapStyleChangeUpdater","_mapState$globe","mapStyle","getColorMode","key","_mapStyle$mapStyles$k","mapStyles","colorMode","prevColorMode","styleType","nextColorMode","mapState","DARK","screen","LIGHT","darken","globe","enabled","basemap","labels","adminLines","water","syncGlobeConfigColorsToStyle","_mapState$globe2","nextStyleObj","nextGlobeConfig","surfaceColor","backgroundFillColor","waterColor","basemapWaterFillColor","adminLinesColor","basemapAdminLineColor","basemapColors","style","layerGroups","combinedSetMapViewModeUpdater","_mapState$globe3","combinedLayerTypeChangeUpdater","oldLayerIndex","findIndex","oldLayer","newLayer","_newState$uiState$map","newState","uiState","isSplit","splitMaps","isLegendActive","mapControls","mapLegend","active","panelId","index","_newUiState$mapContro","mapSplitMode","prevMode","newMapState","newVisState","SINGLE_MAP","DUAL_MAP","SWIPE_COMPARE","duplicate","newUiState","defaultReplaceDataToMapOptions","replaceDataInMapUpdater","_ref3","datasetToReplaceId","datasetToUse","_payload$options","addDataToMapOptions","dataIdToUse","preparedState"],"sources":["../../src/combined-updaters.ts"],"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  receiveMapConfigUpdater as uiStateReceiveMapConfigUpdater\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  setMapSplitModeUpdater as mapStateSetMapSplitModeUpdater,\n  setMapViewModeUpdater\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  MapStateActions\n} from '@kepler.gl/actions';\nimport {VisState} from '@kepler.gl/schemas';\nimport {Layer} from '@kepler.gl/layers';\nimport {isPlainObject, computeSplitMapLayers} from '@kepler.gl/utils';\nimport {findMapBounds} from './data-utils';\nimport {BASE_MAP_COLOR_MODES, OVERLAY_BLENDINGS, NO_MAP_ID, MapSplitMode} from '@kepler.gl/constants';\nimport {getBasemapColorsForStyle, DEFAULT_BASEMAP_COLOR} from '@kepler.gl/deckgl-layers';\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 @typescript-eslint/no-unused-vars */\n// @ts-ignore\nconst combinedUpdaters = null;\n/* eslint-enable @typescript-eslint/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, padding: {left: 300}}`\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 progressive loading dataset by batches, 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      // this part can be async\n      apply_<VisState, any>(visStateUpdateVisDataUpdater, {\n        datasets,\n        options,\n        config: parsedConfig\n      })\n    ),\n\n    if_(Boolean(info), pick_('visState')(apply_<VisState, any>(setMapInfoUpdater, {info}))),\n    // Note that fit bounds here won't be called in case datasets are created in Tasks.\n    // A separate Task to update bounds is created once the datasets are ready.\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')(\n      apply_(uiStateReceiveMapConfigUpdater, payload_({config: parsedConfig, options}))\n    ),\n    pick_('uiState')(apply_(uiStateLoadFilesSuccessUpdater, payload_(null))),\n\n    pick_('uiState')(apply_(toggleModalUpdater, payload_(null))),\n    pick_('uiState')(\n      merge_(\n        Object.prototype.hasOwnProperty.call(options, 'readOnly')\n          ? {readOnly: options.readOnly}\n          : {}\n      )\n    )\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, layerId: string | null = null) =>\n  visState => ({\n    ...visState,\n    layers: visState.layers.map(layer => {\n      if (!layerId || layer.id === layerId) {\n        if (Object.prototype.hasOwnProperty.call(layer.visConfigSettings, '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, mapState} = 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\n  // Update globe config colors when style changes and globe is enabled\n  if (mapState.globe?.enabled) {\n    // Switching from \"No Basemap\" to a basemap - restore basemap sub-toggles\n    if (payload.styleType !== NO_MAP_ID && mapStyle.styleType === NO_MAP_ID) {\n      mapState = {\n        ...mapState,\n        globe: {\n          ...mapState.globe,\n          config: {\n            ...mapState.globe.config,\n            basemap: true,\n            labels: true,\n            adminLines: true,\n            water: true\n          }\n        }\n      };\n    }\n    mapState = syncGlobeConfigColorsToStyle(mapState, mapStyle, payload.styleType);\n  }\n\n  return {\n    ...state,\n    visState,\n    mapState,\n    mapStyle: mapStyleChangeUpdater(mapStyle, {payload: {...payload}})\n  };\n};\n\n/**\n * Derive globe basemap colors (surface / water / admin lines) from a map style and\n * return an updated mapState with those colors written into `globe.config`. Used both\n * when the base map style changes and when entering globe mode, so the globe always\n * reflects the currently selected basemap instead of the static DEFAULT_GLOBE_CONFIG.\n */\nexport function syncGlobeConfigColorsToStyle(\n  mapState: MapState,\n  mapStyle: MapStyle,\n  styleType: string\n): MapState {\n  if (!mapState.globe?.enabled) {\n    return mapState;\n  }\n\n  const nextStyleObj = mapStyle.mapStyles[styleType];\n  const nextGlobeConfig = {...mapState.globe.config};\n\n  if (styleType === NO_MAP_ID) {\n    nextGlobeConfig.basemap = false;\n    nextGlobeConfig.labels = false;\n    nextGlobeConfig.adminLines = false;\n    nextGlobeConfig.water = false;\n    nextGlobeConfig.surfaceColor = DEFAULT_BASEMAP_COLOR.backgroundFillColor;\n    nextGlobeConfig.waterColor = DEFAULT_BASEMAP_COLOR.basemapWaterFillColor;\n    nextGlobeConfig.adminLinesColor = DEFAULT_BASEMAP_COLOR.basemapAdminLineColor;\n  } else {\n    const basemapColors = nextStyleObj\n      ? getBasemapColorsForStyle(styleType, {\n          style: nextStyleObj.style,\n          layerGroups: nextStyleObj.layerGroups\n        })\n      : // Style object not yet loaded - use known presets by style type\n        getBasemapColorsForStyle(styleType);\n    nextGlobeConfig.surfaceColor = basemapColors.backgroundFillColor;\n    nextGlobeConfig.waterColor = basemapColors.basemapWaterFillColor;\n    nextGlobeConfig.adminLinesColor = basemapColors.basemapAdminLineColor;\n  }\n\n  return {\n    ...mapState,\n    globe: {\n      ...mapState.globe,\n      config: nextGlobeConfig\n    }\n  };\n}\n\n/**\n * Updater that switches the map view mode (2D / 3D / Globe). Runs the base map-state\n * updater and, when entering globe mode, syncs the globe basemap colors to the\n * currently selected map style so the globe doesn't show stale default colors.\n */\nexport const combinedSetMapViewModeUpdater = (\n  state: KeplerGlState,\n  action: MapStateActions.SetMapViewModeUpdaterAction\n): KeplerGlState => {\n  let mapState = setMapViewModeUpdater(state.mapState, action);\n\n  if (mapState.globe?.enabled) {\n    mapState = syncGlobeConfigColorsToStyle(mapState, state.mapStyle, state.mapStyle.styleType);\n  }\n\n  return {\n    ...state,\n    mapState\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 (Object.prototype.hasOwnProperty.call(newLayer?.visConfigSettings, '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)\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\n/**\n * Set map split mode updater - coordinates state changes across visState, mapState, and uiState\n */\nexport const setMapSplitModeUpdater = (\n  state: KeplerGlState,\n  action: MapStateActions.SetMapSplitModeUpdaterAction\n): KeplerGlState => {\n  const {mapSplitMode} = action.payload;\n  const prevMode = state.mapState.mapSplitMode;\n\n  if (mapSplitMode === prevMode) {\n    return state;\n  }\n\n  const newMapState = mapStateSetMapSplitModeUpdater(state.mapState, action);\n\n  let newVisState = {...state.visState};\n\n  switch (mapSplitMode) {\n    case MapSplitMode.SINGLE_MAP:\n      newVisState = {\n        ...newVisState,\n        splitMaps: []\n      };\n      break;\n    case MapSplitMode.DUAL_MAP:\n    case MapSplitMode.SWIPE_COMPARE:\n      if (prevMode === MapSplitMode.SINGLE_MAP) {\n        newVisState = {\n          ...newVisState,\n          splitMaps: computeSplitMapLayers(newVisState.layers, {\n            duplicate: mapSplitMode === MapSplitMode.SWIPE_COMPARE\n          })\n        };\n      }\n      break;\n    default:\n      break;\n  }\n\n  let newUiState = uiStateToggleSplitMapUpdater(state.uiState);\n\n  const isSplit = newVisState.splitMaps.length !== 0;\n  const isLegendActive = newUiState.mapControls?.mapLegend?.active;\n  if (isSplit && !isLegendActive) {\n    newUiState = toggleMapControlUpdater(newUiState, {\n      payload: {panelId: 'mapLegend', index: 0}\n    });\n  }\n\n  return {\n    ...state,\n    mapState: newMapState,\n    visState: newVisState,\n    uiState: newUiState\n  };\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"],"mappings":"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","ignoreList":[]}