@kepler.gl/reducers 3.3.0-alpha.1 → 3.3.0-alpha.11

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

@@ -0,0 +1,650 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+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 geoViewport from '@mapbox/geo-viewport';
+import { booleanWithin } from '@turf/boolean-within';
+import { bboxPolygon } from '@turf/bbox-polygon';
+import { fitBounds } from '@math.gl/web-mercator';
+import deepmerge from 'deepmerge';
+import pick from 'es-toolkit/compat/pick';
+import { getCenterAndZoomFromBounds, validateBounds, MAPBOX_TILE_SIZE, validateViewPort } from '@kepler.gl/utils';
+import { MapSplitMode, MapViewMode, DEFAULT_GLOBE_CONFIG, GLOBE_MIN_ZOOM, GLOBE_MAX_ZOOM, GLOBE_MAX_LATITUDE } from '@kepler.gl/constants';
+
+/**
+ * Updaters for `mapState` reducer. Can be used in your root reducer to directly modify kepler.gl's state.
+ * Read more about [Using updaters](../advanced-usage/using-updaters.md)
+ * @public
+ * @example
+ *
+ * import keplerGlReducer, {mapStateUpdaters} from '@kepler.gl/reducers';
+ * // Root Reducer
+ * const reducers = combineReducers({
+ *  keplerGl: keplerGlReducer,
+ *  app: appReducer
+ * });
+ *
+ * const composedReducer = (state, action) => {
+ *  switch (action.type) {
+ *    // click button to close side panel
+ *    case 'CLICK_BUTTON':
+ *      return {
+ *        ...state,
+ *        keplerGl: {
+ *          ...state.keplerGl,
+ *          foo: {
+ *             ...state.keplerGl.foo,
+ *             mapState: mapStateUpdaters.fitBoundsUpdater(
+ *               mapState, {payload: [127.34, 31.09, 127.56, 31.59]]}
+ *             )
+ *          }
+ *        }
+ *      };
+ *  }
+ *  return reducers(state, action);
+ * };
+ *
+ * export default composedReducer;
+ */
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// @ts-ignore
+var mapStateUpdaters = null;
+/* eslint-enable @typescript-eslint/no-unused-vars */
+/**
+ * Default initial `mapState`
+ * @memberof mapStateUpdaters
+ * @constant
+ * @property pitch Default: `0`
+ * @property bearing Default: `0`
+ * @property latitude Default: `37.75043`
+ * @property longitude Default: `-122.34679`
+ * @property zoom Default: `9`
+ * @property dragRotate Default: `false`
+ * @property width Default: `800`
+ * @property height Default: `800`
+ * @property minZoom: `undefined`,
+ * @property maxZoom: `undefined`,
+ * @property maxPitch: `undefined` (defaults to application config value, deck.gl default is 60)
+ * @property maxBounds: `undefined`,
+ * @property isSplit: `false`,
+ * @property isViewportSynced: `true`,
+ * @property isZoomLocked: `false`,
+ * @property splitMapViewports: `[]`
+ * @public
+ */
+export var INITIAL_MAP_STATE = {
+  pitch: 0,
+  bearing: 0,
+  latitude: 37.75043,
+  longitude: -122.34679,
+  zoom: 9,
+  dragRotate: false,
+  width: 800,
+  height: 800,
+  minZoom: undefined,
+  maxZoom: undefined,
+  maxPitch: undefined,
+  maxBounds: undefined,
+  isSplit: false,
+  isViewportSynced: true,
+  isZoomLocked: false,
+  splitMapViewports: [],
+  mapViewMode: MapViewMode.MODE_2D,
+  globe: {
+    enabled: false,
+    config: DEFAULT_GLOBE_CONFIG
+  },
+  mapSplitMode: MapSplitMode.SINGLE_MAP,
+  swipeComparePercentage: 50
+};
+
+/* Updaters */
+/**
+ * Update map viewport
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var updateMapUpdater = function updateMapUpdater(state, action) {
+  var _action$payload = action.payload,
+    inputViewport = _action$payload.viewport,
+    _action$payload$mapIn = _action$payload.mapIndex,
+    mapIndex = _action$payload$mapIn === void 0 ? 0 : _action$payload$mapIn;
+  var viewport = validateViewPort(inputViewport);
+  if (state.isViewportSynced) {
+    // The `updateViewport` function is typed as (Viewport, Viewport) -> Viewport but here the
+    // expected typing is (MapState, Viewport) -> MapState.
+    // this could be a potential bug as we treat Viewport and MapState as equal seemingly
+    // @ts-expect-error Type 'Viewport' is missing the following properties from type 'MapState': isSplit, isViewportSynced, isZoomLocked, splitMapViewports
+    return updateViewport(state, viewport);
+  }
+  var otherViewportMapIndex = -1;
+  var splitMapViewports = state.splitMapViewports.map(function (currentViewport, i) {
+    if (i === mapIndex) {
+      // update the matching viewport with the newViewport info in the action payload
+      return updateViewport(currentViewport, viewport);
+    }
+    otherViewportMapIndex = i;
+    // make no changes to the other viewport (yet)
+    return currentViewport;
+  });
+
+  // make conditional updates to the other viewport not matching this payload's `mapIndex`
+  if (Number.isFinite(otherViewportMapIndex) && otherViewportMapIndex > -1) {
+    // width and height are a special case and are always updated
+    splitMapViewports[otherViewportMapIndex] = _objectSpread(_objectSpread({}, splitMapViewports[otherViewportMapIndex]), {}, {
+      width: splitMapViewports[mapIndex].width,
+      height: splitMapViewports[mapIndex].height
+    });
+    if (state.isZoomLocked) {
+      // update the other viewport with the new zoom from the split viewport that was updated with this payload's `mapIndex`
+      splitMapViewports[otherViewportMapIndex] = _objectSpread(_objectSpread({}, splitMapViewports[otherViewportMapIndex]), {}, {
+        zoom: splitMapViewports[mapIndex].zoom
+      });
+    }
+  }
+  return _objectSpread(_objectSpread(_objectSpread({}, state), splitMapViewports[mapIndex]), {}, {
+    // update the mapState with the new array of split viewports
+    splitMapViewports: splitMapViewports
+  });
+};
+
+/**
+ * Fit map viewport to bounds
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var fitBoundsUpdater = function fitBoundsUpdater(state, action) {
+  var _action$meta, _state$globe;
+  var centerAndZoom = getCenterAndZoomFromBounds(action.payload, {
+    width: state.width,
+    height: state.height,
+    padding: (_action$meta = action.meta) === null || _action$meta === void 0 ? void 0 : _action$meta.padding
+  });
+  if (!centerAndZoom) {
+    // bounds is invalid
+    return state;
+  }
+
+  // In globe mode, clamp zoom to globe's allowed range
+  var isGlobeMode = Boolean((_state$globe = state.globe) === null || _state$globe === void 0 ? void 0 : _state$globe.enabled);
+  var zoom = Number.isFinite(centerAndZoom.zoom) ? isGlobeMode ? Math.min(Math.max(centerAndZoom.zoom, GLOBE_MIN_ZOOM), GLOBE_MAX_ZOOM) : centerAndZoom.zoom : undefined;
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    latitude: centerAndZoom.center[1],
+    longitude: centerAndZoom.center[0]
+  }, zoom !== undefined ? {
+    zoom: zoom
+  } : {});
+
+  // if fitting to bounds while split and unsynced
+  // copy the new latitude, longitude, and zoom values to each split viewport
+  if (newState.splitMapViewports.length) {
+    newState.splitMapViewports = newState.splitMapViewports.map(function (currentViewport) {
+      return _objectSpread(_objectSpread({}, currentViewport), {}, {
+        latitude: newState.latitude,
+        longitude: newState.longitude,
+        zoom: newState.zoom
+      });
+    });
+  }
+  return newState;
+};
+
+/**
+ * Toggle between 3d and 2d map.
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var togglePerspectiveUpdater = function togglePerspectiveUpdater(state) {
+  var _state$globe2;
+  // Only drop min/maxZoom when we're actually leaving globe mode, where those
+  // bounds are set to globe-only values. If globe was never enabled these are
+  // the app's own custom bounds and must be preserved.
+  var wasGlobeEnabled = Boolean((_state$globe2 = state.globe) === null || _state$globe2 === void 0 ? void 0 : _state$globe2.enabled);
+  var newState = _objectSpread(_objectSpread(_objectSpread({}, state), {
+    pitch: state.dragRotate ? 0 : 50,
+    bearing: state.dragRotate ? 0 : 24
+  }), {}, {
+    dragRotate: !state.dragRotate,
+    mapViewMode: state.dragRotate ? MapViewMode.MODE_2D : MapViewMode.MODE_3D,
+    globe: _objectSpread(_objectSpread({}, state.globe), {}, {
+      enabled: false
+    })
+  }, wasGlobeEnabled ? {
+    minZoom: undefined,
+    maxZoom: undefined
+  } : {});
+
+  // if toggling 3d and 2d while split and unsynced
+  // copy the new pitch, bearing, and dragRotate values to each split viewport
+  if (newState.splitMapViewports.length) {
+    newState.splitMapViewports = newState.splitMapViewports.map(function (currentViewport) {
+      return _objectSpread(_objectSpread({}, currentViewport), {}, {
+        pitch: newState.pitch,
+        bearing: newState.bearing,
+        dragRotate: newState.dragRotate
+      });
+    });
+  }
+  return newState;
+};
+
+/**
+ * Set map view mode (2D, 3D, Globe)
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var setMapViewModeUpdater = function setMapViewModeUpdater(state, action) {
+  var _state$globe3;
+  var mapViewMode = action.payload.mapViewMode;
+  var nextState;
+
+  // Only clear min/maxZoom when leaving globe mode (where they hold globe-only
+  // bounds). Otherwise preserve the app's custom bounds.
+  var wasGlobeEnabled = Boolean((_state$globe3 = state.globe) === null || _state$globe3 === void 0 ? void 0 : _state$globe3.enabled);
+  switch (mapViewMode) {
+    case MapViewMode.MODE_2D:
+      nextState = _objectSpread(_objectSpread(_objectSpread({}, state), {}, {
+        globe: _objectSpread(_objectSpread({}, state.globe), {}, {
+          enabled: false
+        }),
+        pitch: 0,
+        bearing: 0,
+        dragRotate: false
+      }, wasGlobeEnabled ? {
+        minZoom: undefined,
+        maxZoom: undefined
+      } : {}), {}, {
+        mapViewMode: mapViewMode
+      });
+      break;
+    case MapViewMode.MODE_3D:
+      nextState = _objectSpread(_objectSpread(_objectSpread({}, state), {}, {
+        globe: _objectSpread(_objectSpread({}, state.globe), {}, {
+          enabled: false
+        }),
+        pitch: 50,
+        bearing: 24,
+        dragRotate: true
+      }, wasGlobeEnabled ? {
+        minZoom: undefined,
+        maxZoom: undefined
+      } : {}), {}, {
+        mapViewMode: mapViewMode
+      });
+      break;
+    case MapViewMode.MODE_GLOBE:
+      nextState = _objectSpread(_objectSpread({}, state), {}, {
+        globe: _objectSpread(_objectSpread({}, state.globe), {}, {
+          enabled: true
+        }),
+        dragRotate: true,
+        pitch: 0,
+        bearing: 0,
+        // Allow zooming out further than the default so the whole globe can be
+        // pulled back on screen. Cap the max zoom so the basemap tiles stay
+        // coherent (they break down at high globe zoom in deck.gl 9.x).
+        minZoom: GLOBE_MIN_ZOOM,
+        maxZoom: GLOBE_MAX_ZOOM,
+        zoom: Math.min(Math.max(state.zoom, GLOBE_MIN_ZOOM), GLOBE_MAX_ZOOM),
+        mapViewMode: mapViewMode
+      });
+      break;
+    default:
+      return state;
+  }
+  if (nextState.splitMapViewports.length) {
+    nextState.splitMapViewports = nextState.splitMapViewports.map(function (currentViewport) {
+      return _objectSpread(_objectSpread({}, currentViewport), {}, {
+        pitch: nextState.pitch,
+        bearing: nextState.bearing,
+        dragRotate: nextState.dragRotate
+      });
+    });
+  }
+  return nextState;
+};
+
+/**
+ * Update globe config
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var globeConfigChangeUpdater = function globeConfigChangeUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    globe: _objectSpread(_objectSpread({}, state.globe), {}, {
+      config: _objectSpread(_objectSpread({}, state.globe.config), action.payload)
+    })
+  });
+};
+
+/**
+ * reset mapState to initial State
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var resetMapConfigUpdater = function resetMapConfigUpdater(state) {
+  return _objectSpread(_objectSpread(_objectSpread({}, INITIAL_MAP_STATE), state.initialState), {}, {
+    initialState: state.initialState
+  });
+};
+
+// consider case where you have a split map and user wants to reset
+/**
+ * Update `mapState` to propagate a new config
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var receiveMapConfigUpdater = function receiveMapConfigUpdater(state, _ref) {
+  var _ref$payload = _ref.payload,
+    _ref$payload$config = _ref$payload.config,
+    config = _ref$payload$config === void 0 ? {} : _ref$payload$config,
+    _ref$payload$options = _ref$payload.options,
+    options = _ref$payload$options === void 0 ? {} : _ref$payload$options,
+    _ref$payload$bounds = _ref$payload.bounds,
+    bounds = _ref$payload$bounds === void 0 ? null : _ref$payload$bounds;
+  /**
+   * @type {Partial<MapState>}
+   */
+  var mapState = (config || {}).mapState || {};
+  // merged received mapState with previous state
+  // state also may include properties that are new to an existing, saved project's mapState
+
+  var mergedState = deepmerge(state, mapState, {
+    // note: deepmerge by default will merge arrays by concatenating them
+    // but we need to overwrite destination arrays with source arrays, if present
+    // https://github.com/TehShrike/deepmerge#arraymerge-example-overwrite-target-array
+    arrayMerge: function arrayMerge(_destinationArray, sourceArray) {
+      return sourceArray;
+    }
+  });
+
+  // if center map
+  // center map will override mapState config
+  if (options.centerMap && bounds) {
+    mergedState = fitBoundsUpdater(mergedState, {
+      payload: bounds,
+      meta: {
+        padding: options.padding
+      }
+    });
+  }
+
+  // make sure we validate map state before we merge
+  mergedState = validateViewPort(mergedState);
+  return _objectSpread(_objectSpread({}, mergedState), getMapDimForSplitMap(mergedState.isSplit, state));
+};
+
+/**
+ * Toggle between one or split maps
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var toggleSplitMapUpdater = function toggleSplitMapUpdater(state) {
+  return _objectSpread(_objectSpread(_objectSpread({}, state), getMapDimForSplitMap(!state.isSplit, state)), {}, {
+    isSplit: !state.isSplit,
+    mapSplitMode: !state.isSplit ? MapSplitMode.DUAL_MAP : MapSplitMode.SINGLE_MAP
+  }, !state.isSplit === false ? {
+    // if toggling to no longer split (single mode) then reset a few properties
+    isViewportSynced: true,
+    isZoomLocked: false,
+    splitMapViewports: []
+  } : {});
+};
+
+/**
+ * Set the map split mode (single, dual, or swipe)
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var setMapSplitModeUpdater = function setMapSplitModeUpdater(state, action) {
+  var mapSplitMode = action.payload.mapSplitMode;
+  var prevMode = state.mapSplitMode;
+  if (mapSplitMode === prevMode) {
+    return state;
+  }
+  switch (mapSplitMode) {
+    case MapSplitMode.SINGLE_MAP:
+      return _objectSpread(_objectSpread(_objectSpread({}, state), {}, {
+        mapSplitMode: mapSplitMode,
+        isSplit: false
+      }, prevMode === MapSplitMode.DUAL_MAP && {
+        width: state.width * 2
+      }), {}, {
+        isViewportSynced: true,
+        isZoomLocked: false,
+        splitMapViewports: []
+      });
+    case MapSplitMode.DUAL_MAP:
+      return _objectSpread(_objectSpread(_objectSpread({}, state), {}, {
+        mapSplitMode: mapSplitMode,
+        isSplit: true
+      }, prevMode === MapSplitMode.SINGLE_MAP && {
+        width: state.width / 2
+      }), prevMode === MapSplitMode.SWIPE_COMPARE && {
+        width: state.width / 2
+      });
+    case MapSplitMode.SWIPE_COMPARE:
+      return _objectSpread(_objectSpread(_objectSpread({}, state), {}, {
+        mapSplitMode: mapSplitMode,
+        isSplit: true
+      }, prevMode === MapSplitMode.DUAL_MAP && {
+        width: state.width * 2
+      }), {}, {
+        isViewportSynced: true,
+        isZoomLocked: false,
+        splitMapViewports: []
+      });
+    default:
+      return state;
+  }
+};
+
+/**
+ * Set the swipe compare percentage
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var setSwipeComparePercentageUpdater = function setSwipeComparePercentageUpdater(state, action) {
+  var percentage = action.payload.percentage;
+  var clamped = Math.min(100, Math.max(0, percentage));
+  if (clamped === state.swipeComparePercentage) {
+    return state;
+  }
+  return _objectSpread(_objectSpread({}, state), {}, {
+    swipeComparePercentage: clamped
+  });
+};
+
+/**
+ * Toggle between locked and unlocked split viewports
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export var toggleSplitMapViewportUpdater = function toggleSplitMapViewportUpdater(state, action) {
+  // Swipe mode always uses synced viewports
+  if (state.mapSplitMode === MapSplitMode.SWIPE_COMPARE) {
+    return state;
+  }
+
+  // new map state immediately gets the new, optional payload values for isViewportSynced and/or isZoomLocked
+  var newMapState = _objectSpread(_objectSpread({}, state), action.payload || {});
+  if (newMapState.isViewportSynced) {
+    // switching from unsynced to synced viewports
+    newMapState.splitMapViewports = [];
+  } else {
+    // switching from synced to unsynced viewports
+    // or already in unsynced mode and toggling locked zoom
+
+    if (state.isZoomLocked && !newMapState.isZoomLocked) {
+      // switching off locked zoom while unsynced
+      // don't copy the mapStates to left and right viewports because there will be zoom "jumping"
+      return newMapState;
+    }
+    if (!state.isZoomLocked && newMapState.isZoomLocked) {
+      // switching on locked zoom while unsynced
+      // only copy zoom viewport property from the most recently interacted-with viewport to the other
+      // TODO: do we want to check for a match a different way, such as a combo of `latitude` and `longitude`?
+      var lastUpdatedViewportIndex = newMapState.splitMapViewports.findIndex(function (v) {
+        return newMapState.zoom === v.zoom;
+      });
+      var splitMapViewports = newMapState.splitMapViewports.map(function (currentViewport, i) {
+        if (i === lastUpdatedViewportIndex) {
+          // no zoom to modify here
+          return currentViewport;
+        }
+        // the other viewport gets the most recently interacted-with viewport's zoom
+        // WHY? the viewport the user was last interacting with will set zoom across the board for smooth UX
+        return _objectSpread(_objectSpread({}, currentViewport), {}, {
+          zoom: newMapState.splitMapViewports[lastUpdatedViewportIndex].zoom
+        });
+      });
+      newMapState.splitMapViewports = splitMapViewports;
+      return newMapState;
+    }
+
+    // if current viewport is synced, and we are unsyncing it
+    // or already in unsynced mode and NOT toggling locked zoom
+    // make a fresh copy of the current viewport object, assign it to splitMapViewports[]
+    // pickViewportPropsFromMapState is called twice to avoid memory allocation conflicts
+    var leftViewport = pickViewportPropsFromMapState(newMapState);
+    var rightViewport = pickViewportPropsFromMapState(newMapState);
+    newMapState.splitMapViewports = [leftViewport, rightViewport];
+  }
+
+  // return new state
+  return newMapState;
+};
+
+// Helpers
+export function getMapDimForSplitMap(isSplit, state) {
+  // cases:
+  // 1. state split: true - isSplit: true
+  // do nothing
+  // 2. state split: false - isSplit: false
+  // do nothing
+  if (state.isSplit === isSplit) {
+    return {};
+  }
+
+  // In swipe mode, both maps use full width (overlapping with clip)
+  if (state.mapSplitMode === MapSplitMode.SWIPE_COMPARE) {
+    return {};
+  }
+  var width = state.isSplit && !isSplit ?
+  // 3. state split: true - isSplit: false
+  // double width
+  state.width * 2 :
+  // 4. state split: false - isSplit: true
+  // split width
+  state.width / 2;
+  return {
+    width: width
+  };
+}
+function updateViewportBasedOnBounds(state, newMapState) {
+  // Get the new viewport bounds
+  var viewportBounds = geoViewport.bounds([newMapState.longitude, newMapState.latitude], newMapState.zoom, [newMapState.width, newMapState.height], MAPBOX_TILE_SIZE);
+  // Generate turf Polygon from bounds for comparison
+  var viewportBoundsPolygon = bboxPolygon(viewportBounds);
+  // @ts-ignore
+  var newStateMaxBounds = newMapState.maxBounds;
+  // @ts-ignore
+  var maxBoundsPolygon = bboxPolygon(newStateMaxBounds);
+
+  // If maxBounds has changed reset the viewport to snap to bounds
+  var hasMaxBoundsChanged = !state.maxBounds || !state.maxBounds.every(function (val, idx) {
+    return val === newStateMaxBounds[idx];
+  });
+  if (hasMaxBoundsChanged) {
+    // Check if the newMapState viewport is within maxBounds
+    if (!booleanWithin(viewportBoundsPolygon, maxBoundsPolygon)) {
+      var _fitBounds = fitBounds({
+          width: newMapState.width,
+          height: newMapState.height,
+          bounds: [[newStateMaxBounds[0], newStateMaxBounds[1]], [newStateMaxBounds[2], newStateMaxBounds[3]]]
+        }),
+        latitude = _fitBounds.latitude,
+        longitude = _fitBounds.longitude,
+        zoom = _fitBounds.zoom;
+      newMapState = _objectSpread(_objectSpread({}, newMapState), {}, {
+        latitude: latitude,
+        longitude: longitude
+      }, Number.isFinite(zoom) ? {
+        zoom: zoom
+      } : {});
+    }
+    return newMapState;
+  }
+
+  // Check if the newMapState viewport is within maxBounds
+  if (!booleanWithin(viewportBoundsPolygon, maxBoundsPolygon)) {
+    newMapState = _objectSpread(_objectSpread({}, newMapState), {}, {
+      longitude: state.longitude,
+      latitude: state.latitude,
+      zoom: state.zoom
+    });
+  }
+  return newMapState;
+}
+export function pickViewportPropsFromMapState(state) {
+  return pick(state, ['width', 'height', 'zoom', 'pitch', 'bearing', 'latitude', 'longitude', 'dragRotate', 'minZoom', 'maxZoom', 'maxPitch', 'maxBounds']);
+}
+
+/** Select items from object whose value is not undefined */
+var definedProps = function definedProps(obj) {
+  return Object.entries(obj).reduce(function (accu, _ref2) {
+    var _ref3 = _slicedToArray(_ref2, 2),
+      k = _ref3[0],
+      v = _ref3[1];
+    return _objectSpread(_objectSpread({}, accu), v !== undefined ? _defineProperty({}, k, v) : {});
+  }, {});
+};
+function updateViewport(originalViewport, viewportUpdates) {
+  var _globe;
+  var newViewport = _objectSpread(_objectSpread({}, originalViewport), definedProps(viewportUpdates) || {});
+
+  // deck.gl's globe controller applies a latitude-dependent adjustment to the
+  // zoom range (see KeplerGlobeView._constrainZoom). If we clamp the propagated
+  // zoom here against the raw minZoom/maxZoom (without that adjustment), Redux
+  // ends up disagreeing with the controller: the controller lets the user pull
+  // the globe further out, but this clamp snaps zoom back to `minZoom` when the
+  // interaction's inertia transition ends. Apply the same adjustment in globe
+  // mode so Redux stays consistent with the controller and there's no snap-back.
+  var isGlobe = (_globe = newViewport.globe) === null || _globe === void 0 ? void 0 : _globe.enabled;
+  if (isGlobe) {
+    var _newViewport$latitude;
+    // Keep the camera target within a latitude band around the equator so the
+    // stored viewport can't be centered on the poles (matches the globe
+    // controller's applyConstraints so geocoder/programmatic updates agree).
+    if (typeof newViewport.latitude === 'number') {
+      newViewport.latitude = Math.min(GLOBE_MAX_LATITUDE, Math.max(-GLOBE_MAX_LATITUDE, newViewport.latitude));
+    }
+    var zoomAdjustment = Math.log2(Math.cos(((_newViewport$latitude = newViewport.latitude) !== null && _newViewport$latitude !== void 0 ? _newViewport$latitude : 0) * Math.PI / 180));
+    if (typeof newViewport.minZoom === 'number' && typeof newViewport.zoom === 'number' && newViewport.zoom < newViewport.minZoom + zoomAdjustment) {
+      newViewport.zoom = newViewport.minZoom + zoomAdjustment;
+    }
+    if (typeof newViewport.maxZoom === 'number' && typeof newViewport.zoom === 'number' && newViewport.zoom > newViewport.maxZoom + zoomAdjustment) {
+      newViewport.zoom = newViewport.maxZoom + zoomAdjustment;
+    }
+  } else {
+    // Make sure zoom level doesn't go bellow minZoom if defined
+    if (newViewport.minZoom && newViewport.zoom && newViewport.zoom < newViewport.minZoom) {
+      newViewport.zoom = newViewport.minZoom;
+    }
+    // Make sure zoom level doesn't go above maxZoom if defined
+    if (newViewport.maxZoom && newViewport.zoom && newViewport.zoom > newViewport.maxZoom) {
+      newViewport.zoom = newViewport.maxZoom;
+    }
+  }
+  // Limit viewport update based on maxBounds
+  if (newViewport.maxBounds && validateBounds(newViewport.maxBounds)) {
+    // @ts-expect-error Type 'Viewport' is missing the following properties from type 'MapState': isSplit, isViewportSynced, isZoomLocked, splitMapViewports
+    newViewport = updateViewportBasedOnBounds(originalViewport, newViewport);
+  }
+  return newViewport;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["geoViewport","booleanWithin","bboxPolygon","fitBounds","deepmerge","pick","getCenterAndZoomFromBounds","validateBounds","MAPBOX_TILE_SIZE","validateViewPort","MapSplitMode","MapViewMode","DEFAULT_GLOBE_CONFIG","GLOBE_MIN_ZOOM","GLOBE_MAX_ZOOM","GLOBE_MAX_LATITUDE","mapStateUpdaters","INITIAL_MAP_STATE","pitch","bearing","latitude","longitude","zoom","dragRotate","width","height","minZoom","undefined","maxZoom","maxPitch","maxBounds","isSplit","isViewportSynced","isZoomLocked","splitMapViewports","mapViewMode","MODE_2D","globe","enabled","config","mapSplitMode","SINGLE_MAP","swipeComparePercentage","updateMapUpdater","state","action","_action$payload","payload","inputViewport","viewport","_action$payload$mapIn","mapIndex","updateViewport","otherViewportMapIndex","map","currentViewport","i","Number","isFinite","_objectSpread","fitBoundsUpdater","_action$meta","_state$globe","centerAndZoom","padding","meta","isGlobeMode","Boolean","Math","min","max","newState","center","length","togglePerspectiveUpdater","_state$globe2","wasGlobeEnabled","MODE_3D","setMapViewModeUpdater","_state$globe3","nextState","MODE_GLOBE","globeConfigChangeUpdater","resetMapConfigUpdater","initialState","receiveMapConfigUpdater","_ref","_ref$payload","_ref$payload$config","_ref$payload$options","options","_ref$payload$bounds","bounds","mapState","mergedState","arrayMerge","_destinationArray","sourceArray","centerMap","getMapDimForSplitMap","toggleSplitMapUpdater","DUAL_MAP","setMapSplitModeUpdater","prevMode","SWIPE_COMPARE","setSwipeComparePercentageUpdater","percentage","clamped","toggleSplitMapViewportUpdater","newMapState","lastUpdatedViewportIndex","findIndex","v","leftViewport","pickViewportPropsFromMapState","rightViewport","updateViewportBasedOnBounds","viewportBounds","viewportBoundsPolygon","newStateMaxBounds","maxBoundsPolygon","hasMaxBoundsChanged","every","val","idx","_fitBounds","definedProps","obj","Object","entries","reduce","accu","_ref2","_ref3","_slicedToArray","k","_defineProperty","originalViewport","viewportUpdates","_globe","newViewport","isGlobe","_newViewport$latitude","zoomAdjustment","log2","cos","PI"],"sources":["../../src/map-state-updaters.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport geoViewport from '@mapbox/geo-viewport';\nimport {booleanWithin} from '@turf/boolean-within';\nimport {bboxPolygon} from '@turf/bbox-polygon';\nimport {fitBounds} from '@math.gl/web-mercator';\nimport deepmerge from 'deepmerge';\nimport pick from 'es-toolkit/compat/pick';\n\nimport {\n  getCenterAndZoomFromBounds,\n  validateBounds,\n  MAPBOX_TILE_SIZE,\n  validateViewPort\n} from '@kepler.gl/utils';\nimport {MapStateActions, ReceiveMapConfigPayload, ActionTypes} from '@kepler.gl/actions';\nimport {MapState, Bounds, Viewport} from '@kepler.gl/types';\nimport {\n  MapSplitMode,\n  MapViewMode,\n  DEFAULT_GLOBE_CONFIG,\n  GLOBE_MIN_ZOOM,\n  GLOBE_MAX_ZOOM,\n  GLOBE_MAX_LATITUDE\n} from '@kepler.gl/constants';\n\n/**\n * Updaters for `mapState` reducer. Can be used in your root reducer to directly modify kepler.gl's state.\n * Read more about [Using updaters](../advanced-usage/using-updaters.md)\n * @public\n * @example\n *\n * import keplerGlReducer, {mapStateUpdaters} from '@kepler.gl/reducers';\n * // Root Reducer\n * const reducers = combineReducers({\n *  keplerGl: keplerGlReducer,\n *  app: appReducer\n * });\n *\n * const composedReducer = (state, action) => {\n *  switch (action.type) {\n *    // click button to close side panel\n *    case 'CLICK_BUTTON':\n *      return {\n *        ...state,\n *        keplerGl: {\n *          ...state.keplerGl,\n *          foo: {\n *             ...state.keplerGl.foo,\n *             mapState: mapStateUpdaters.fitBoundsUpdater(\n *               mapState, {payload: [127.34, 31.09, 127.56, 31.59]]}\n *             )\n *          }\n *        }\n *      };\n *  }\n *  return reducers(state, action);\n * };\n *\n * export default composedReducer;\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n// @ts-ignore\nconst mapStateUpdaters = null;\n/* eslint-enable @typescript-eslint/no-unused-vars */\n/**\n * Default initial `mapState`\n * @memberof mapStateUpdaters\n * @constant\n * @property pitch Default: `0`\n * @property bearing Default: `0`\n * @property latitude Default: `37.75043`\n * @property longitude Default: `-122.34679`\n * @property zoom Default: `9`\n * @property dragRotate Default: `false`\n * @property width Default: `800`\n * @property height Default: `800`\n * @property minZoom: `undefined`,\n * @property maxZoom: `undefined`,\n * @property maxPitch: `undefined` (defaults to application config value, deck.gl default is 60)\n * @property maxBounds: `undefined`,\n * @property isSplit: `false`,\n * @property isViewportSynced: `true`,\n * @property isZoomLocked: `false`,\n * @property splitMapViewports: `[]`\n * @public\n */\nexport const INITIAL_MAP_STATE: MapState = {\n  pitch: 0,\n  bearing: 0,\n  latitude: 37.75043,\n  longitude: -122.34679,\n  zoom: 9,\n  dragRotate: false,\n  width: 800,\n  height: 800,\n  minZoom: undefined,\n  maxZoom: undefined,\n  maxPitch: undefined,\n  maxBounds: undefined,\n  isSplit: false,\n  isViewportSynced: true,\n  isZoomLocked: false,\n  splitMapViewports: [],\n  mapViewMode: MapViewMode.MODE_2D,\n  globe: {\n    enabled: false,\n    config: DEFAULT_GLOBE_CONFIG\n  },\n  mapSplitMode: MapSplitMode.SINGLE_MAP,\n  swipeComparePercentage: 50\n};\n\n/* Updaters */\n/**\n * Update map viewport\n * @memberof mapStateUpdaters\n * @public\n */\nexport const updateMapUpdater = (\n  state: MapState,\n  action: MapStateActions.UpdateMapUpdaterAction\n): MapState => {\n  const {viewport: inputViewport, mapIndex = 0} = action.payload;\n  const viewport = validateViewPort(inputViewport);\n\n  if (state.isViewportSynced) {\n    // The `updateViewport` function is typed as (Viewport, Viewport) -> Viewport but here the\n    // expected typing is (MapState, Viewport) -> MapState.\n    // this could be a potential bug as we treat Viewport and MapState as equal seemingly\n    // @ts-expect-error Type 'Viewport' is missing the following properties from type 'MapState': isSplit, isViewportSynced, isZoomLocked, splitMapViewports\n    return updateViewport(state, viewport);\n  }\n\n  let otherViewportMapIndex = -1;\n  const splitMapViewports = state.splitMapViewports.map((currentViewport, i) => {\n    if (i === mapIndex) {\n      // update the matching viewport with the newViewport info in the action payload\n      return updateViewport(currentViewport, viewport);\n    }\n\n    otherViewportMapIndex = i;\n    // make no changes to the other viewport (yet)\n    return currentViewport;\n  });\n\n  // make conditional updates to the other viewport not matching this payload's `mapIndex`\n  if (Number.isFinite(otherViewportMapIndex) && otherViewportMapIndex > -1) {\n    // width and height are a special case and are always updated\n    splitMapViewports[otherViewportMapIndex] = {\n      ...splitMapViewports[otherViewportMapIndex],\n      width: splitMapViewports[mapIndex].width,\n      height: splitMapViewports[mapIndex].height\n    };\n\n    if (state.isZoomLocked) {\n      // update the other viewport with the new zoom from the split viewport that was updated with this payload's `mapIndex`\n      splitMapViewports[otherViewportMapIndex] = {\n        ...splitMapViewports[otherViewportMapIndex],\n        zoom: splitMapViewports[mapIndex].zoom\n      };\n    }\n  }\n\n  return {\n    // update the top-level mapState viewport with the most recently interacted-with split viewport\n    // WHY? this avoids zoom and bounds \"jumping\" due to a \"stale\" top-level mapState viewport when:\n    //  1. toggling off the unsynced viewports mode to switch to the synced viewports mode\n    //  2. toggling on the zoom lock during an unsynced viewports mode\n    ...state,\n    ...splitMapViewports[mapIndex],\n    // update the mapState with the new array of split viewports\n    splitMapViewports\n  };\n};\n\n/**\n * Fit map viewport to bounds\n * @memberof mapStateUpdaters\n * @public\n */\nexport const fitBoundsUpdater = (\n  state: MapState,\n  action: MapStateActions.FitBoundsUpdaterAction\n): MapState => {\n  const centerAndZoom = getCenterAndZoomFromBounds(action.payload, {\n    width: state.width,\n    height: state.height,\n    padding: action.meta?.padding\n  });\n  if (!centerAndZoom) {\n    // bounds is invalid\n    return state;\n  }\n\n  // In globe mode, clamp zoom to globe's allowed range\n  const isGlobeMode = Boolean(state.globe?.enabled);\n  const zoom = Number.isFinite(centerAndZoom.zoom)\n    ? isGlobeMode\n      ? Math.min(Math.max(centerAndZoom.zoom, GLOBE_MIN_ZOOM), GLOBE_MAX_ZOOM)\n      : centerAndZoom.zoom\n    : undefined;\n\n  const newState = {\n    ...state,\n    latitude: centerAndZoom.center[1],\n    longitude: centerAndZoom.center[0],\n    // For marginal or invalid bounds, zoom may be NaN. Make sure to provide a valid value in order\n    // to avoid corrupt state and potential crashes as zoom is expected to be a number\n    ...(zoom !== undefined ? {zoom} : {})\n  };\n\n  // if fitting to bounds while split and unsynced\n  // copy the new latitude, longitude, and zoom values to each split viewport\n  if (newState.splitMapViewports.length) {\n    newState.splitMapViewports = newState.splitMapViewports.map(currentViewport => ({\n      ...currentViewport,\n      latitude: newState.latitude,\n      longitude: newState.longitude,\n      zoom: newState.zoom\n    }));\n  }\n\n  return newState;\n};\n\n/**\n * Toggle between 3d and 2d map.\n * @memberof mapStateUpdaters\n * @public\n */\nexport const togglePerspectiveUpdater = (state: MapState): MapState => {\n  // Only drop min/maxZoom when we're actually leaving globe mode, where those\n  // bounds are set to globe-only values. If globe was never enabled these are\n  // the app's own custom bounds and must be preserved.\n  const wasGlobeEnabled = Boolean(state.globe?.enabled);\n\n  const newState = {\n    ...state,\n    ...{\n      pitch: state.dragRotate ? 0 : 50,\n      bearing: state.dragRotate ? 0 : 24\n    },\n    dragRotate: !state.dragRotate,\n    mapViewMode: state.dragRotate ? MapViewMode.MODE_2D : MapViewMode.MODE_3D,\n    globe: {...state.globe!, enabled: false},\n    // Leaving globe mode: drop globe-only zoom bounds so the flat map (and\n    // consumers of mapState such as video export) aren't left clamped. When\n    // globe was never on, keep whatever min/maxZoom the app configured.\n    ...(wasGlobeEnabled ? {minZoom: undefined, maxZoom: undefined} : {})\n  };\n\n  // if toggling 3d and 2d while split and unsynced\n  // copy the new pitch, bearing, and dragRotate values to each split viewport\n  if (newState.splitMapViewports.length) {\n    newState.splitMapViewports = newState.splitMapViewports.map(currentViewport => ({\n      ...currentViewport,\n      pitch: newState.pitch,\n      bearing: newState.bearing,\n      dragRotate: newState.dragRotate\n    }));\n  }\n\n  return newState;\n};\n\n/**\n * Set map view mode (2D, 3D, Globe)\n * @memberof mapStateUpdaters\n * @public\n */\nexport const setMapViewModeUpdater = (\n  state: MapState,\n  action: MapStateActions.SetMapViewModeUpdaterAction\n): MapState => {\n  const {mapViewMode} = action.payload;\n  let nextState: MapState;\n\n  // Only clear min/maxZoom when leaving globe mode (where they hold globe-only\n  // bounds). Otherwise preserve the app's custom bounds.\n  const wasGlobeEnabled = Boolean(state.globe?.enabled);\n\n  switch (mapViewMode) {\n    case MapViewMode.MODE_2D:\n      nextState = {\n        ...state,\n        globe: {...state.globe!, enabled: false},\n        pitch: 0,\n        bearing: 0,\n        dragRotate: false,\n        // Clear the globe-only zoom bounds so the flat map (and anything that\n        // reads mapState, e.g. video export) is not left with globe's\n        // min/maxZoom after leaving globe mode. Only when globe was actually on.\n        ...(wasGlobeEnabled ? {minZoom: undefined, maxZoom: undefined} : {}),\n        mapViewMode\n      };\n      break;\n    case MapViewMode.MODE_3D:\n      nextState = {\n        ...state,\n        globe: {...state.globe!, enabled: false},\n        pitch: 50,\n        bearing: 24,\n        dragRotate: true,\n        ...(wasGlobeEnabled ? {minZoom: undefined, maxZoom: undefined} : {}),\n        mapViewMode\n      };\n      break;\n    case MapViewMode.MODE_GLOBE:\n      nextState = {\n        ...state,\n        globe: {...state.globe!, enabled: true},\n        dragRotate: true,\n        pitch: 0,\n        bearing: 0,\n        // Allow zooming out further than the default so the whole globe can be\n        // pulled back on screen. Cap the max zoom so the basemap tiles stay\n        // coherent (they break down at high globe zoom in deck.gl 9.x).\n        minZoom: GLOBE_MIN_ZOOM,\n        maxZoom: GLOBE_MAX_ZOOM,\n        zoom: Math.min(Math.max(state.zoom, GLOBE_MIN_ZOOM), GLOBE_MAX_ZOOM),\n        mapViewMode\n      };\n      break;\n    default:\n      return state;\n  }\n\n  if (nextState.splitMapViewports.length) {\n    nextState.splitMapViewports = nextState.splitMapViewports.map(currentViewport => ({\n      ...currentViewport,\n      pitch: nextState.pitch,\n      bearing: nextState.bearing,\n      dragRotate: nextState.dragRotate\n    }));\n  }\n\n  return nextState;\n};\n\n/**\n * Update globe config\n * @memberof mapStateUpdaters\n * @public\n */\nexport const globeConfigChangeUpdater = (\n  state: MapState,\n  action: MapStateActions.GlobeConfigChangeUpdaterAction\n): MapState => {\n  return {\n    ...state,\n    globe: {\n      ...state.globe!,\n      config: {\n        ...state.globe!.config,\n        ...action.payload\n      }\n    }\n  };\n};\n\n/**\n * reset mapState to initial State\n * @memberof mapStateUpdaters\n * @public\n */\nexport const resetMapConfigUpdater = (state: MapState): MapState => ({\n  ...INITIAL_MAP_STATE,\n  ...state.initialState,\n  initialState: state.initialState\n});\n\n// consider case where you have a split map and user wants to reset\n/**\n * Update `mapState` to propagate a new config\n * @memberof mapStateUpdaters\n * @public\n */\nexport const receiveMapConfigUpdater = (\n  state: MapState,\n  {\n    // @ts-expect-error\n    payload: {config = {}, options = {}, bounds = null}\n  }: {\n    type?: typeof ActionTypes.RECEIVE_MAP_CONFIG;\n    payload: ReceiveMapConfigPayload;\n  }\n): MapState => {\n  /**\n   * @type {Partial<MapState>}\n   */\n  const mapState = (config || {}).mapState || {};\n  // merged received mapState with previous state\n  // state also may include properties that are new to an existing, saved project's mapState\n\n  let mergedState = deepmerge<MapState>(state, mapState, {\n    // note: deepmerge by default will merge arrays by concatenating them\n    // but we need to overwrite destination arrays with source arrays, if present\n    // https://github.com/TehShrike/deepmerge#arraymerge-example-overwrite-target-array\n    arrayMerge: (_destinationArray, sourceArray) => sourceArray\n  });\n\n  // if center map\n  // center map will override mapState config\n  if (options.centerMap && bounds) {\n    mergedState = fitBoundsUpdater(mergedState, {\n      payload: bounds,\n      meta: {padding: options.padding}\n    });\n  }\n\n  // make sure we validate map state before we merge\n  mergedState = validateViewPort(mergedState);\n\n  return {\n    ...mergedState,\n    // update width if `isSplit` has changed\n    ...getMapDimForSplitMap(mergedState.isSplit, state)\n  };\n};\n\n/**\n * Toggle between one or split maps\n * @memberof mapStateUpdaters\n * @public\n */\nexport const toggleSplitMapUpdater = (state: MapState): MapState => ({\n  ...state,\n  ...getMapDimForSplitMap(!state.isSplit, state),\n  isSplit: !state.isSplit,\n  mapSplitMode: !state.isSplit ? MapSplitMode.DUAL_MAP : MapSplitMode.SINGLE_MAP,\n  ...(!state.isSplit === false\n    ? {\n        // if toggling to no longer split (single mode) then reset a few properties\n        isViewportSynced: true,\n        isZoomLocked: false,\n        splitMapViewports: []\n      }\n    : {})\n});\n\n/**\n * Set the map split mode (single, dual, or swipe)\n * @memberof mapStateUpdaters\n * @public\n */\nexport const setMapSplitModeUpdater = (\n  state: MapState,\n  action: MapStateActions.SetMapSplitModeUpdaterAction\n): MapState => {\n  const {mapSplitMode} = action.payload;\n  const prevMode = state.mapSplitMode;\n\n  if (mapSplitMode === prevMode) {\n    return state;\n  }\n\n  switch (mapSplitMode) {\n    case MapSplitMode.SINGLE_MAP:\n      return {\n        ...state,\n        mapSplitMode,\n        isSplit: false,\n        ...(prevMode === MapSplitMode.DUAL_MAP && {\n          width: state.width * 2\n        }),\n        isViewportSynced: true,\n        isZoomLocked: false,\n        splitMapViewports: []\n      };\n    case MapSplitMode.DUAL_MAP:\n      return {\n        ...state,\n        mapSplitMode,\n        isSplit: true,\n        ...(prevMode === MapSplitMode.SINGLE_MAP && {\n          width: state.width / 2\n        }),\n        ...(prevMode === MapSplitMode.SWIPE_COMPARE && {\n          width: state.width / 2\n        })\n      };\n    case MapSplitMode.SWIPE_COMPARE:\n      return {\n        ...state,\n        mapSplitMode,\n        isSplit: true,\n        ...(prevMode === MapSplitMode.DUAL_MAP && {\n          width: state.width * 2\n        }),\n        isViewportSynced: true,\n        isZoomLocked: false,\n        splitMapViewports: []\n      };\n    default:\n      return state;\n  }\n};\n\n/**\n * Set the swipe compare percentage\n * @memberof mapStateUpdaters\n * @public\n */\nexport const setSwipeComparePercentageUpdater = (\n  state: MapState,\n  action: MapStateActions.SetSwipeComparePercentageUpdaterAction\n): MapState => {\n  const {percentage} = action.payload;\n  const clamped = Math.min(100, Math.max(0, percentage));\n  if (clamped === state.swipeComparePercentage) {\n    return state;\n  }\n  return {\n    ...state,\n    swipeComparePercentage: clamped\n  };\n};\n\n/**\n * Toggle between locked and unlocked split viewports\n * @memberof mapStateUpdaters\n * @public\n */\nexport const toggleSplitMapViewportUpdater = (\n  state: MapState,\n  action: MapStateActions.ToggleSplitMapViewportUpdaterAction\n) => {\n  // Swipe mode always uses synced viewports\n  if (state.mapSplitMode === MapSplitMode.SWIPE_COMPARE) {\n    return state;\n  }\n\n  // new map state immediately gets the new, optional payload values for isViewportSynced and/or isZoomLocked\n  const newMapState = {\n    ...state,\n    ...(action.payload || {})\n  };\n\n  if (newMapState.isViewportSynced) {\n    // switching from unsynced to synced viewports\n    newMapState.splitMapViewports = [];\n  } else {\n    // switching from synced to unsynced viewports\n    // or already in unsynced mode and toggling locked zoom\n\n    if (state.isZoomLocked && !newMapState.isZoomLocked) {\n      // switching off locked zoom while unsynced\n      // don't copy the mapStates to left and right viewports because there will be zoom \"jumping\"\n      return newMapState;\n    }\n\n    if (!state.isZoomLocked && newMapState.isZoomLocked) {\n      // switching on locked zoom while unsynced\n      // only copy zoom viewport property from the most recently interacted-with viewport to the other\n      // TODO: do we want to check for a match a different way, such as a combo of `latitude` and `longitude`?\n      const lastUpdatedViewportIndex = newMapState.splitMapViewports.findIndex(\n        v => newMapState.zoom === v.zoom\n      );\n\n      const splitMapViewports = newMapState.splitMapViewports.map((currentViewport, i) => {\n        if (i === lastUpdatedViewportIndex) {\n          // no zoom to modify here\n          return currentViewport;\n        }\n        // the other viewport gets the most recently interacted-with viewport's zoom\n        // WHY? the viewport the user was last interacting with will set zoom across the board for smooth UX\n        return {\n          ...currentViewport,\n          zoom: newMapState.splitMapViewports[lastUpdatedViewportIndex].zoom\n        };\n      });\n\n      newMapState.splitMapViewports = splitMapViewports;\n\n      return newMapState;\n    }\n\n    // if current viewport is synced, and we are unsyncing it\n    // or already in unsynced mode and NOT toggling locked zoom\n    // make a fresh copy of the current viewport object, assign it to splitMapViewports[]\n    // pickViewportPropsFromMapState is called twice to avoid memory allocation conflicts\n    const leftViewport = pickViewportPropsFromMapState(newMapState);\n    const rightViewport = pickViewportPropsFromMapState(newMapState);\n    newMapState.splitMapViewports = [leftViewport, rightViewport];\n  }\n\n  // return new state\n  return newMapState;\n};\n\n// Helpers\nexport function getMapDimForSplitMap(isSplit, state) {\n  // cases:\n  // 1. state split: true - isSplit: true\n  // do nothing\n  // 2. state split: false - isSplit: false\n  // do nothing\n  if (state.isSplit === isSplit) {\n    return {};\n  }\n\n  // In swipe mode, both maps use full width (overlapping with clip)\n  if (state.mapSplitMode === MapSplitMode.SWIPE_COMPARE) {\n    return {};\n  }\n\n  const width =\n    state.isSplit && !isSplit\n      ? // 3. state split: true - isSplit: false\n        // double width\n        state.width * 2\n      : // 4. state split: false - isSplit: true\n        // split width\n        state.width / 2;\n\n  return {\n    width\n  };\n}\n\nfunction updateViewportBasedOnBounds(state: MapState, newMapState: MapState) {\n  // Get the new viewport bounds\n  const viewportBounds = geoViewport.bounds(\n    [newMapState.longitude, newMapState.latitude],\n    newMapState.zoom,\n    [newMapState.width, newMapState.height],\n    MAPBOX_TILE_SIZE\n  );\n  // Generate turf Polygon from bounds for comparison\n  const viewportBoundsPolygon = bboxPolygon(viewportBounds);\n  // @ts-ignore\n  const newStateMaxBounds: Bounds = newMapState.maxBounds;\n  // @ts-ignore\n  const maxBoundsPolygon = bboxPolygon(newStateMaxBounds);\n\n  // If maxBounds has changed reset the viewport to snap to bounds\n  const hasMaxBoundsChanged =\n    !state.maxBounds || !state.maxBounds.every((val, idx) => val === newStateMaxBounds[idx]);\n  if (hasMaxBoundsChanged) {\n    // Check if the newMapState viewport is within maxBounds\n    if (!booleanWithin(viewportBoundsPolygon, maxBoundsPolygon)) {\n      const {latitude, longitude, zoom} = fitBounds({\n        width: newMapState.width,\n        height: newMapState.height,\n        bounds: [\n          [newStateMaxBounds[0], newStateMaxBounds[1]],\n          [newStateMaxBounds[2], newStateMaxBounds[3]]\n        ]\n      });\n\n      newMapState = {\n        ...newMapState,\n        latitude,\n        longitude,\n        // For marginal or invalid bounds, zoom may be NaN. Make sure to provide a valid value in order\n        // to avoid corrupt state and potential crashes as zoom is expected to be a number\n        ...(Number.isFinite(zoom) ? {zoom} : {})\n      };\n    }\n    return newMapState;\n  }\n\n  // Check if the newMapState viewport is within maxBounds\n  if (!booleanWithin(viewportBoundsPolygon, maxBoundsPolygon)) {\n    newMapState = {\n      ...newMapState,\n      longitude: state.longitude,\n      latitude: state.latitude,\n      zoom: state.zoom\n    };\n  }\n\n  return newMapState;\n}\n\nexport function pickViewportPropsFromMapState(state: MapState): Viewport {\n  return pick(state, [\n    'width',\n    'height',\n    'zoom',\n    'pitch',\n    'bearing',\n    'latitude',\n    'longitude',\n    'dragRotate',\n    'minZoom',\n    'maxZoom',\n    'maxPitch',\n    'maxBounds'\n  ]);\n}\n\n/** Select items from object whose value is not undefined */\nconst definedProps = obj =>\n  Object.entries(obj).reduce(\n    (accu, [k, v]) => ({...accu, ...(v !== undefined ? {[k]: v} : {})}),\n    {}\n  );\n\nfunction updateViewport(originalViewport: Viewport, viewportUpdates: Viewport): Viewport {\n  let newViewport = {\n    ...originalViewport,\n    ...(definedProps(viewportUpdates) || {})\n  };\n\n  // deck.gl's globe controller applies a latitude-dependent adjustment to the\n  // zoom range (see KeplerGlobeView._constrainZoom). If we clamp the propagated\n  // zoom here against the raw minZoom/maxZoom (without that adjustment), Redux\n  // ends up disagreeing with the controller: the controller lets the user pull\n  // the globe further out, but this clamp snaps zoom back to `minZoom` when the\n  // interaction's inertia transition ends. Apply the same adjustment in globe\n  // mode so Redux stays consistent with the controller and there's no snap-back.\n  const isGlobe = (newViewport as any).globe?.enabled;\n\n  if (isGlobe) {\n    // Keep the camera target within a latitude band around the equator so the\n    // stored viewport can't be centered on the poles (matches the globe\n    // controller's applyConstraints so geocoder/programmatic updates agree).\n    if (typeof newViewport.latitude === 'number') {\n      newViewport.latitude = Math.min(\n        GLOBE_MAX_LATITUDE,\n        Math.max(-GLOBE_MAX_LATITUDE, newViewport.latitude)\n      );\n    }\n    const zoomAdjustment = Math.log2(Math.cos(((newViewport.latitude ?? 0) * Math.PI) / 180));\n    if (\n      typeof newViewport.minZoom === 'number' &&\n      typeof newViewport.zoom === 'number' &&\n      newViewport.zoom < newViewport.minZoom + zoomAdjustment\n    ) {\n      newViewport.zoom = newViewport.minZoom + zoomAdjustment;\n    }\n    if (\n      typeof newViewport.maxZoom === 'number' &&\n      typeof newViewport.zoom === 'number' &&\n      newViewport.zoom > newViewport.maxZoom + zoomAdjustment\n    ) {\n      newViewport.zoom = newViewport.maxZoom + zoomAdjustment;\n    }\n  } else {\n    // Make sure zoom level doesn't go bellow minZoom if defined\n    if (newViewport.minZoom && newViewport.zoom && newViewport.zoom < newViewport.minZoom) {\n      newViewport.zoom = newViewport.minZoom;\n    }\n    // Make sure zoom level doesn't go above maxZoom if defined\n    if (newViewport.maxZoom && newViewport.zoom && newViewport.zoom > newViewport.maxZoom) {\n      newViewport.zoom = newViewport.maxZoom;\n    }\n  }\n  // Limit viewport update based on maxBounds\n  if (newViewport.maxBounds && validateBounds(newViewport.maxBounds)) {\n    // @ts-expect-error Type 'Viewport' is missing the following properties from type 'MapState': isSplit, isViewportSynced, isZoomLocked, splitMapViewports\n    newViewport = updateViewportBasedOnBounds(originalViewport, newViewport);\n  }\n\n  return newViewport;\n}\n"],"mappings":"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","ignoreList":[]}