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

package/dist/map-state-updaters.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
+// Copyright (c) 2023 Uber Technologies, Inc.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -26,10 +26,25 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getMapDimForSplitMap = getMapDimForSplitMap;
-exports.toggleSplitMapUpdater = exports.receiveMapConfigUpdater = exports.resetMapConfigUpdater = exports.togglePerspectiveUpdater = exports.fitBoundsUpdater = exports.updateMapUpdater = exports.INITIAL_MAP_STATE = void 0;
+exports.pickViewportPropsFromMapState = pickViewportPropsFromMapState;
+exports.toggleSplitMapViewportUpdater = exports.toggleSplitMapUpdater = exports.receiveMapConfigUpdater = exports.resetMapConfigUpdater = exports.togglePerspectiveUpdater = exports.fitBoundsUpdater = exports.updateMapUpdater = exports.INITIAL_MAP_STATE = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
+var _geoViewport = _interopRequireDefault(require("@mapbox/geo-viewport"));
+
+var _booleanWithin = _interopRequireDefault(require("@turf/boolean-within"));
+
+var _bboxPolygon = _interopRequireDefault(require("@turf/bbox-polygon"));
+
+var _webMercator = require("@math.gl/web-mercator");
+
+var _deepmerge = _interopRequireDefault(require("deepmerge"));
+
+var _lodash = _interopRequireDefault(require("lodash.pick"));
+
 var _utils = require("@kepler.gl/utils");
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
@@ -89,7 +104,13 @@ var mapStateUpdaters = null;
  * @property dragRotate Default: `false`
  * @property width Default: `800`
  * @property height Default: `800`
- * @property isSplit Default: `false`
+ * @property minZoom: `undefined`,
+ * @property maxZoom: `undefined`,
+ * @property maxBounds: `undefined`,
+ * @property isSplit: `false`,
+ * @property isViewportSynced: `true`,
+ * @property isZoomLocked: `false`,
+ * @property splitMapViewports: `[]`
  * @public
  */
 
@@ -102,7 +123,13 @@ var INITIAL_MAP_STATE = {
   dragRotate: false,
   width: 800,
   height: 800,
-  isSplit: false
+  minZoom: undefined,
+  maxZoom: undefined,
+  maxBounds: undefined,
+  isSplit: false,
+  isViewportSynced: true,
+  isZoomLocked: false,
+  splitMapViewports: []
 };
 /* Updaters */
 
@@ -115,7 +142,50 @@ var INITIAL_MAP_STATE = {
 exports.INITIAL_MAP_STATE = INITIAL_MAP_STATE;
 
 var updateMapUpdater = function updateMapUpdater(state, action) {
-  return _objectSpread(_objectSpread({}, state), action.payload || {});
+  var _action$payload = action.payload,
+      viewport = _action$payload.viewport,
+      _action$payload$mapIn = _action$payload.mapIndex,
+      mapIndex = _action$payload$mapIn === void 0 ? 0 : _action$payload$mapIn;
+
+  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
@@ -137,12 +207,26 @@ var fitBoundsUpdater = function fitBoundsUpdater(state, action) {
     return state;
   }
 
-  return _objectSpread(_objectSpread({}, state), {}, {
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
     latitude: centerAndZoom.center[1],
     longitude: centerAndZoom.center[0]
   }, Number.isFinite(centerAndZoom.zoom) ? {
     zoom: centerAndZoom.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.
@@ -154,12 +238,26 @@ var fitBoundsUpdater = function fitBoundsUpdater(state, action) {
 exports.fitBoundsUpdater = fitBoundsUpdater;
 
 var togglePerspectiveUpdater = function togglePerspectiveUpdater(state, action) {
-  return _objectSpread(_objectSpread(_objectSpread({}, state), {
+  var newState = _objectSpread(_objectSpread(_objectSpread({}, state), {
     pitch: state.dragRotate ? 0 : 50,
     bearing: state.dragRotate ? 0 : 24
   }), {}, {
     dragRotate: !state.dragRotate
-  });
+  }); // 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;
 };
 /**
  * reset mapState to initial State
@@ -194,14 +292,22 @@ var receiveMapConfigUpdater = function receiveMapConfigUpdater(state, _ref) {
       _ref$payload$bounds = _ref$payload.bounds,
       bounds = _ref$payload$bounds === void 0 ? null : _ref$payload$bounds;
 
-  var _ref2 = config || {},
-      mapState = _ref2.mapState; // merged received mapstate with previous state
-
-
-  var mergedState = _objectSpread(_objectSpread({}, state), mapState); // if center map
+  /**
+   * @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 = (0, _deepmerge["default"])(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
@@ -220,14 +326,79 @@ var receiveMapConfigUpdater = function receiveMapConfigUpdater(state, _ref) {
 exports.receiveMapConfigUpdater = receiveMapConfigUpdater;
 
 var toggleSplitMapUpdater = function toggleSplitMapUpdater(state, action) {
-  return _objectSpread(_objectSpread({}, state), {}, {
+  return _objectSpread(_objectSpread(_objectSpread({}, state), getMapDimForSplitMap(!state.isSplit, state)), {}, {
     isSplit: !state.isSplit
-  }, getMapDimForSplitMap(!state.isSplit, state));
-}; // Helpers
+  }, !state.isSplit === false ? {
+    // if toggling to no longer split (single mode) then reset a few properties
+    isViewportSynced: true,
+    isZoomLocked: false,
+    splitMapViewports: []
+  } : {});
+};
+/**
+ * Toggle between locked and unlocked split viewports
+ * @memberof mapStateUpdaters
+ * @public
+ */
 
 
 exports.toggleSplitMapUpdater = toggleSplitMapUpdater;
 
+var toggleSplitMapViewportUpdater = function toggleSplitMapViewportUpdater(state, action) {
+  // 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
+
+
+exports.toggleSplitMapViewportUpdater = toggleSplitMapViewportUpdater;
+
 function getMapDimForSplitMap(isSplit, state) {
   // cases:
   // 1. state split: true - isSplit: true
@@ -247,4 +418,92 @@ function getMapDimForSplitMap(isSplit, state) {
     width: width
   };
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/map-state-updaters.ts"],"names":["mapStateUpdaters","INITIAL_MAP_STATE","pitch","bearing","latitude","longitude","zoom","dragRotate","width","height","isSplit","updateMapUpdater","state","action","payload","fitBoundsUpdater","centerAndZoom","center","Number","isFinite","togglePerspectiveUpdater","resetMapConfigUpdater","initialState","receiveMapConfigUpdater","config","options","bounds","mapState","mergedState","centerMap","getMapDimForSplitMap","toggleSplitMapUpdater"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {getCenterAndZoomFromBounds} from '@kepler.gl/utils';\nimport {MapStateActions, ReceiveMapConfigPayload, ActionTypes} from '@kepler.gl/actions';\nimport {MapState} from '@kepler.gl/types';\n\n/**\n * Updaters for `mapState` reducer. Can be used in your root reducer to directly modify kepler.gl's state.\n * Read more about [Using updaters](../advanced-usage/using-updaters.md)\n * @public\n * @example\n *\n * import keplerGlReducer, {mapStateUpdaters} from 'kepler.gl/reducers';\n * // Root Reducer\n * const reducers = combineReducers({\n *  keplerGl: keplerGlReducer,\n *  app: appReducer\n * });\n *\n * const composedReducer = (state, action) => {\n *  switch (action.type) {\n *    // click button to close side panel\n *    case 'CLICK_BUTTON':\n *      return {\n *        ...state,\n *        keplerGl: {\n *          ...state.keplerGl,\n *          foo: {\n *             ...state.keplerGl.foo,\n *             mapState: mapStateUpdaters.fitBoundsUpdater(\n *               mapState, {payload: [127.34, 31.09, 127.56, 31.59]]}\n *             )\n *          }\n *        }\n *      };\n *  }\n *  return reducers(state, action);\n * };\n *\n * export default composedReducer;\n */\n/* eslint-disable no-unused-vars */\n// @ts-ignore\nconst mapStateUpdaters = null;\n/* eslint-enable no-unused-vars */\n\n/**\n * Default initial `mapState`\n * @memberof mapStateUpdaters\n * @constant\n * @property pitch Default: `0`\n * @property bearing Default: `0`\n * @property latitude Default: `37.75043`\n * @property longitude Default: `-122.34679`\n * @property zoom Default: `9`\n * @property dragRotate Default: `false`\n * @property width Default: `800`\n * @property height Default: `800`\n * @property isSplit Default: `false`\n * @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  isSplit: false\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  ...state,\n  ...(action.payload || {})\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  });\n  if (!centerAndZoom) {\n    // bounds is invalid\n    return state;\n  }\n\n  return {\n    ...state,\n    latitude: centerAndZoom.center[1],\n    longitude: centerAndZoom.center[0],\n    // For marginal or invalid bounds, zoom may be NaN. Make sure to provide a valid value in order\n    // to avoid corrupt state and potential crashes as zoom is expected to be a number\n    ...(Number.isFinite(centerAndZoom.zoom) ? {zoom: centerAndZoom.zoom} : {})\n  };\n};\n\n/**\n * Toggle between 3d and 2d map.\n * @memberof mapStateUpdaters\n * @public\n */\nexport const togglePerspectiveUpdater = (\n  state: MapState,\n  action: MapStateActions.TogglePerspectiveUpdaterAction\n): MapState => ({\n  ...state,\n  ...{\n    pitch: state.dragRotate ? 0 : 50,\n    bearing: state.dragRotate ? 0 : 24\n  },\n  dragRotate: !state.dragRotate\n});\n\n/**\n * reset mapState to initial State\n * @memberof mapStateUpdaters\n * @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  const {mapState} = config || {};\n\n  // merged received mapstate with previous state\n  let mergedState = {...state, ...mapState};\n\n  // if center map\n  // center map will override mapState config\n  if (options.centerMap && bounds) {\n    mergedState = fitBoundsUpdater(mergedState, {\n      payload: bounds\n    });\n  }\n\n  return {\n    ...mergedState,\n    // update width if `isSplit` has changed\n    ...getMapDimForSplitMap(mergedState.isSplit, state)\n  };\n};\n\n/**\n * Toggle between one or split maps\n * @memberof mapStateUpdaters\n * @public\n */\nexport const toggleSplitMapUpdater = (\n  state: MapState,\n  action: MapStateActions.ToggleSplitMapUpdaterAction\n): MapState => ({\n  ...state,\n  isSplit: !state.isSplit,\n  ...getMapDimForSplitMap(!state.isSplit, state)\n});\n\n// Helpers\nexport function getMapDimForSplitMap(isSplit, state) {\n  // cases:\n  // 1. state split: true - isSplit: true\n  // do nothing\n  // 2. state split: false - isSplit: false\n  // do nothing\n  if (state.isSplit === isSplit) {\n    return {};\n  }\n\n  const width =\n    state.isSplit && !isSplit\n      ? // 3. state split: true - isSplit: false\n        // double width\n        state.width * 2\n      : // 4. state split: false - isSplit: true\n        // split width\n        state.width / 2;\n\n  return {\n    width\n  };\n}\n"]}
+
+function updateViewportBasedOnBounds(state, newMapState) {
+  // Get the new viewport bounds
+  var viewportBounds = _geoViewport["default"].bounds([newMapState.longitude, newMapState.latitude], newMapState.zoom, [newMapState.width, newMapState.height], _utils.MAPBOX_TILE_SIZE); // Generate turf Polygon from bounds for comparison
+
+
+  var viewportBoundsPolygon = (0, _bboxPolygon["default"])(viewportBounds); // @ts-ignore
+
+  var newStateMaxBounds = newMapState.maxBounds; // @ts-ignore
+
+  var maxBoundsPolygon = (0, _bboxPolygon["default"])(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 (!(0, _booleanWithin["default"])(viewportBoundsPolygon, maxBoundsPolygon)) {
+      var _fitBounds = (0, _webMercator.fitBounds)({
+        width: newMapState.width,
+        height: newMapState.width,
+        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 (!(0, _booleanWithin["default"])(viewportBoundsPolygon, maxBoundsPolygon)) {
+    newMapState = _objectSpread(_objectSpread({}, newMapState), {}, {
+      longitude: state.longitude,
+      latitude: state.latitude,
+      zoom: state.zoom
+    });
+  }
+
+  return newMapState;
+}
+
+function pickViewportPropsFromMapState(state) {
+  return (0, _lodash["default"])(state, ['width', 'height', 'zoom', 'pitch', 'bearing', 'latitude', 'longitude', 'dragRotate', 'minZoom', 'maxZoom', '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 = (0, _slicedToArray2["default"])(_ref2, 2),
+        k = _ref3[0],
+        v = _ref3[1];
+
+    return _objectSpread(_objectSpread({}, accu), v !== undefined ? (0, _defineProperty2["default"])({}, k, v) : {});
+  }, {});
+};
+
+function updateViewport(originalViewport, viewportUpdates) {
+  var newViewport = _objectSpread(_objectSpread({}, originalViewport), definedProps(viewportUpdates) || {}); // 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 && (0, _utils.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,"sources":["../src/map-state-updaters.ts"],"names":["mapStateUpdaters","INITIAL_MAP_STATE","pitch","bearing","latitude","longitude","zoom","dragRotate","width","height","minZoom","undefined","maxZoom","maxBounds","isSplit","isViewportSynced","isZoomLocked","splitMapViewports","updateMapUpdater","state","action","payload","viewport","mapIndex","updateViewport","otherViewportMapIndex","map","currentViewport","i","Number","isFinite","fitBoundsUpdater","centerAndZoom","newState","center","length","togglePerspectiveUpdater","resetMapConfigUpdater","initialState","receiveMapConfigUpdater","config","options","bounds","mapState","mergedState","arrayMerge","_destinationArray","sourceArray","centerMap","getMapDimForSplitMap","toggleSplitMapUpdater","toggleSplitMapViewportUpdater","newMapState","lastUpdatedViewportIndex","findIndex","v","leftViewport","pickViewportPropsFromMapState","rightViewport","updateViewportBasedOnBounds","viewportBounds","geoViewport","MAPBOX_TILE_SIZE","viewportBoundsPolygon","newStateMaxBounds","maxBoundsPolygon","hasMaxBoundsChanged","every","val","idx","definedProps","obj","Object","entries","reduce","accu","k","originalViewport","viewportUpdates","newViewport"],"mappings":";;;;;;;;;;;;;;;AAoBA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA;;;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA;AACA;AACA,IAAMA,gBAAgB,GAAG,IAAzB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACO,IAAMC,iBAA2B,GAAG;AACzCC,EAAAA,KAAK,EAAE,CADkC;AAEzCC,EAAAA,OAAO,EAAE,CAFgC;AAGzCC,EAAAA,QAAQ,EAAE,QAH+B;AAIzCC,EAAAA,SAAS,EAAE,CAAC,SAJ6B;AAKzCC,EAAAA,IAAI,EAAE,CALmC;AAMzCC,EAAAA,UAAU,EAAE,KAN6B;AAOzCC,EAAAA,KAAK,EAAE,GAPkC;AAQzCC,EAAAA,MAAM,EAAE,GARiC;AASzCC,EAAAA,OAAO,EAAEC,SATgC;AAUzCC,EAAAA,OAAO,EAAED,SAVgC;AAWzCE,EAAAA,SAAS,EAAEF,SAX8B;AAYzCG,EAAAA,OAAO,EAAE,KAZgC;AAazCC,EAAAA,gBAAgB,EAAE,IAbuB;AAczCC,EAAAA,YAAY,EAAE,KAd2B;AAezCC,EAAAA,iBAAiB,EAAE;AAfsB,CAApC;AAkBP;;AACA;AACA;AACA;AACA;AACA;;;;AACO,IAAMC,gBAAgB,GAAG,SAAnBA,gBAAmB,CAC9BC,KAD8B,EAE9BC,MAF8B,EAGjB;AAAA,wBACoBA,MAAM,CAACC,OAD3B;AAAA,MACNC,QADM,mBACNA,QADM;AAAA,8CACIC,QADJ;AAAA,MACIA,QADJ,sCACe,CADf;;AAGb,MAAIJ,KAAK,CAACJ,gBAAV,EAA4B;AAC1B;AACA;AACA;AACA;AACA,WAAOS,cAAc,CAACL,KAAD,EAAQG,QAAR,CAArB;AACD;;AAED,MAAIG,qBAAqB,GAAG,CAAC,CAA7B;AACA,MAAMR,iBAAiB,GAAGE,KAAK,CAACF,iBAAN,CAAwBS,GAAxB,CAA4B,UAACC,eAAD,EAAkBC,CAAlB,EAAwB;AAC5E,QAAIA,CAAC,KAAKL,QAAV,EAAoB;AAClB;AACA,aAAOC,cAAc,CAACG,eAAD,EAAkBL,QAAlB,CAArB;AACD;;AAEDG,IAAAA,qBAAqB,GAAGG,CAAxB,CAN4E,CAO5E;;AACA,WAAOD,eAAP;AACD,GATyB,CAA1B,CAZa,CAuBb;;AACA,MAAIE,MAAM,CAACC,QAAP,CAAgBL,qBAAhB,KAA0CA,qBAAqB,GAAG,CAAC,CAAvE,EAA0E;AACxE;AACAR,IAAAA,iBAAiB,CAACQ,qBAAD,CAAjB,mCACKR,iBAAiB,CAACQ,qBAAD,CADtB;AAEEjB,MAAAA,KAAK,EAAES,iBAAiB,CAACM,QAAD,CAAjB,CAA4Bf,KAFrC;AAGEC,MAAAA,MAAM,EAAEQ,iBAAiB,CAACM,QAAD,CAAjB,CAA4Bd;AAHtC;;AAMA,QAAIU,KAAK,CAACH,YAAV,EAAwB;AACtB;AACAC,MAAAA,iBAAiB,CAACQ,qBAAD,CAAjB,mCACKR,iBAAiB,CAACQ,qBAAD,CADtB;AAEEnB,QAAAA,IAAI,EAAEW,iBAAiB,CAACM,QAAD,CAAjB,CAA4BjB;AAFpC;AAID;AACF;;AAED,uDAKKa,KALL,GAMKF,iBAAiB,CAACM,QAAD,CANtB;AAOE;AACAN,IAAAA,iBAAiB,EAAjBA;AARF;AAUD,CAtDM;AAwDP;AACA;AACA;AACA;AACA;;;;;AACO,IAAMc,gBAAgB,GAAG,SAAnBA,gBAAmB,CAC9BZ,KAD8B,EAE9BC,MAF8B,EAGjB;AACb,MAAMY,aAAa,GAAG,uCAA2BZ,MAAM,CAACC,OAAlC,EAA2C;AAC/Db,IAAAA,KAAK,EAAEW,KAAK,CAACX,KADkD;AAE/DC,IAAAA,MAAM,EAAEU,KAAK,CAACV;AAFiD,GAA3C,CAAtB;;AAIA,MAAI,CAACuB,aAAL,EAAoB;AAClB;AACA,WAAOb,KAAP;AACD;;AAED,MAAMc,QAAQ,mCACTd,KADS;AAEZf,IAAAA,QAAQ,EAAE4B,aAAa,CAACE,MAAd,CAAqB,CAArB,CAFE;AAGZ7B,IAAAA,SAAS,EAAE2B,aAAa,CAACE,MAAd,CAAqB,CAArB;AAHC,KAMRL,MAAM,CAACC,QAAP,CAAgBE,aAAa,CAAC1B,IAA9B,IAAsC;AAACA,IAAAA,IAAI,EAAE0B,aAAa,CAAC1B;AAArB,GAAtC,GAAmE,EAN3D,CAAd,CAVa,CAmBb;AACA;;;AACA,MAAI2B,QAAQ,CAAChB,iBAAT,CAA2BkB,MAA/B,EAAuC;AACrCF,IAAAA,QAAQ,CAAChB,iBAAT,GAA6BgB,QAAQ,CAAChB,iBAAT,CAA2BS,GAA3B,CAA+B,UAAAC,eAAe;AAAA,6CACtEA,eADsE;AAEzEvB,QAAAA,QAAQ,EAAE6B,QAAQ,CAAC7B,QAFsD;AAGzEC,QAAAA,SAAS,EAAE4B,QAAQ,CAAC5B,SAHqD;AAIzEC,QAAAA,IAAI,EAAE2B,QAAQ,CAAC3B;AAJ0D;AAAA,KAA9C,CAA7B;AAMD;;AAED,SAAO2B,QAAP;AACD,CAlCM;AAoCP;AACA;AACA;AACA;AACA;;;;;AACO,IAAMG,wBAAwB,GAAG,SAA3BA,wBAA2B,CACtCjB,KADsC,EAEtCC,MAFsC,EAGzB;AACb,MAAMa,QAAQ,iDACTd,KADS,GAET;AACDjB,IAAAA,KAAK,EAAEiB,KAAK,CAACZ,UAAN,GAAmB,CAAnB,GAAuB,EAD7B;AAEDJ,IAAAA,OAAO,EAAEgB,KAAK,CAACZ,UAAN,GAAmB,CAAnB,GAAuB;AAF/B,GAFS;AAMZA,IAAAA,UAAU,EAAE,CAACY,KAAK,CAACZ;AANP,IAAd,CADa,CAUb;AACA;;;AACA,MAAI0B,QAAQ,CAAChB,iBAAT,CAA2BkB,MAA/B,EAAuC;AACrCF,IAAAA,QAAQ,CAAChB,iBAAT,GAA6BgB,QAAQ,CAAChB,iBAAT,CAA2BS,GAA3B,CAA+B,UAAAC,eAAe;AAAA,6CACtEA,eADsE;AAEzEzB,QAAAA,KAAK,EAAE+B,QAAQ,CAAC/B,KAFyD;AAGzEC,QAAAA,OAAO,EAAE8B,QAAQ,CAAC9B,OAHuD;AAIzEI,QAAAA,UAAU,EAAE0B,QAAQ,CAAC1B;AAJoD;AAAA,KAA9C,CAA7B;AAMD;;AAED,SAAO0B,QAAP;AACD,CAzBM;AA2BP;AACA;AACA;AACA;AACA;;;;;AACO,IAAMI,qBAAqB,GAAG,SAAxBA,qBAAwB,CAAClB,KAAD;AAAA,uDAChClB,iBADgC,GAEhCkB,KAAK,CAACmB,YAF0B;AAGnCA,IAAAA,YAAY,EAAEnB,KAAK,CAACmB;AAHe;AAAA,CAA9B,C,CAMP;;AACA;AACA;AACA;AACA;AACA;;;;;AACO,IAAMC,uBAAuB,GAAG,SAA1BA,uBAA0B,CACrCpB,KADqC,QASxB;AAAA,0BALXE,OAKW;AAAA,yCALDmB,MAKC;AAAA,MALDA,MAKC,oCALQ,EAKR;AAAA,0CALYC,OAKZ;AAAA,MALYA,OAKZ,qCALsB,EAKtB;AAAA,yCAL0BC,MAK1B;AAAA,MAL0BA,MAK1B,oCALmC,IAKnC;;AACb;AACF;AACA;AACE,MAAMC,QAAQ,GAAG,CAACH,MAAM,IAAI,EAAX,EAAeG,QAAf,IAA2B,EAA5C,CAJa,CAKb;AACA;;AAEA,MAAIC,WAAW,GAAG,2BAAoBzB,KAApB,EAA2BwB,QAA3B,EAAqC;AACrD;AACA;AACA;AACAE,IAAAA,UAAU,EAAE,oBAACC,iBAAD,EAAoBC,WAApB;AAAA,aAAoCA,WAApC;AAAA;AAJyC,GAArC,CAAlB,CARa,CAeb;AACA;;AACA,MAAIN,OAAO,CAACO,SAAR,IAAqBN,MAAzB,EAAiC;AAC/BE,IAAAA,WAAW,GAAGb,gBAAgB,CAACa,WAAD,EAAc;AAC1CvB,MAAAA,OAAO,EAAEqB;AADiC,KAAd,CAA9B;AAGD;;AAED,yCACKE,WADL,GAGKK,oBAAoB,CAACL,WAAW,CAAC9B,OAAb,EAAsBK,KAAtB,CAHzB;AAKD,CArCM;AAuCP;AACA;AACA;AACA;AACA;;;;;AACO,IAAM+B,qBAAqB,GAAG,SAAxBA,qBAAwB,CACnC/B,KADmC,EAEnCC,MAFmC;AAAA,uDAIhCD,KAJgC,GAKhC8B,oBAAoB,CAAC,CAAC9B,KAAK,CAACL,OAAR,EAAiBK,KAAjB,CALY;AAMnCL,IAAAA,OAAO,EAAE,CAACK,KAAK,CAACL;AANmB,KAO/B,CAACK,KAAK,CAACL,OAAP,KAAmB,KAAnB,GACA;AACE;AACAC,IAAAA,gBAAgB,EAAE,IAFpB;AAGEC,IAAAA,YAAY,EAAE,KAHhB;AAIEC,IAAAA,iBAAiB,EAAE;AAJrB,GADA,GAOA,EAd+B;AAAA,CAA9B;AAiBP;AACA;AACA;AACA;AACA;;;;;AACO,IAAMkC,6BAA6B,GAAG,SAAhCA,6BAAgC,CAC3ChC,KAD2C,EAE3CC,MAF2C,EAGxC;AACH;AACA,MAAMgC,WAAW,mCACZjC,KADY,GAEXC,MAAM,CAACC,OAAP,IAAkB,EAFP,CAAjB;;AAKA,MAAI+B,WAAW,CAACrC,gBAAhB,EAAkC;AAChC;AACAqC,IAAAA,WAAW,CAACnC,iBAAZ,GAAgC,EAAhC;AACD,GAHD,MAGO;AACL;AACA;AAEA,QAAIE,KAAK,CAACH,YAAN,IAAsB,CAACoC,WAAW,CAACpC,YAAvC,EAAqD;AACnD;AACA;AACA,aAAOoC,WAAP;AACD;;AAED,QAAI,CAACjC,KAAK,CAACH,YAAP,IAAuBoC,WAAW,CAACpC,YAAvC,EAAqD;AACnD;AACA;AACA;AACA,UAAMqC,wBAAwB,GAAGD,WAAW,CAACnC,iBAAZ,CAA8BqC,SAA9B,CAC/B,UAAAC,CAAC;AAAA,eAAIH,WAAW,CAAC9C,IAAZ,KAAqBiD,CAAC,CAACjD,IAA3B;AAAA,OAD8B,CAAjC;AAIA,UAAMW,iBAAiB,GAAGmC,WAAW,CAACnC,iBAAZ,CAA8BS,GAA9B,CAAkC,UAACC,eAAD,EAAkBC,CAAlB,EAAwB;AAClF,YAAIA,CAAC,KAAKyB,wBAAV,EAAoC;AAClC;AACA,iBAAO1B,eAAP;AACD,SAJiF,CAKlF;AACA;;;AACA,+CACKA,eADL;AAEErB,UAAAA,IAAI,EAAE8C,WAAW,CAACnC,iBAAZ,CAA8BoC,wBAA9B,EAAwD/C;AAFhE;AAID,OAXyB,CAA1B;AAaA8C,MAAAA,WAAW,CAACnC,iBAAZ,GAAgCA,iBAAhC;AAEA,aAAOmC,WAAP;AACD,KAlCI,CAoCL;AACA;AACA;AACA;;;AACA,QAAMI,YAAY,GAAGC,6BAA6B,CAACL,WAAD,CAAlD;AACA,QAAMM,aAAa,GAAGD,6BAA6B,CAACL,WAAD,CAAnD;AACAA,IAAAA,WAAW,CAACnC,iBAAZ,GAAgC,CAACuC,YAAD,EAAeE,aAAf,CAAhC;AACD,GArDE,CAuDH;;;AACA,SAAON,WAAP;AACD,CA5DM,C,CA8DP;;;;;AACO,SAASH,oBAAT,CAA8BnC,OAA9B,EAAuCK,KAAvC,EAA8C;AACnD;AACA;AACA;AACA;AACA;AACA,MAAIA,KAAK,CAACL,OAAN,KAAkBA,OAAtB,EAA+B;AAC7B,WAAO,EAAP;AACD;;AAED,MAAMN,KAAK,GACTW,KAAK,CAACL,OAAN,IAAiB,CAACA,OAAlB,GACI;AACA;AACAK,EAAAA,KAAK,CAACX,KAAN,GAAc,CAHlB,GAII;AACA;AACAW,EAAAA,KAAK,CAACX,KAAN,GAAc,CAPpB;AASA,SAAO;AACLA,IAAAA,KAAK,EAALA;AADK,GAAP;AAGD;;AAED,SAASmD,2BAAT,CAAqCxC,KAArC,EAAsDiC,WAAtD,EAA6E;AAC3E;AACA,MAAMQ,cAAc,GAAGC,wBAAYnB,MAAZ,CACrB,CAACU,WAAW,CAAC/C,SAAb,EAAwB+C,WAAW,CAAChD,QAApC,CADqB,EAErBgD,WAAW,CAAC9C,IAFS,EAGrB,CAAC8C,WAAW,CAAC5C,KAAb,EAAoB4C,WAAW,CAAC3C,MAAhC,CAHqB,EAIrBqD,uBAJqB,CAAvB,CAF2E,CAQ3E;;;AACA,MAAMC,qBAAqB,GAAG,6BAAYH,cAAZ,CAA9B,CAT2E,CAU3E;;AACA,MAAMI,iBAAyB,GAAGZ,WAAW,CAACvC,SAA9C,CAX2E,CAY3E;;AACA,MAAMoD,gBAAgB,GAAG,6BAAYD,iBAAZ,CAAzB,CAb2E,CAe3E;;AACA,MAAME,mBAAmB,GACvB,CAAC/C,KAAK,CAACN,SAAP,IAAoB,CAACM,KAAK,CAACN,SAAN,CAAgBsD,KAAhB,CAAsB,UAACC,GAAD,EAAMC,GAAN;AAAA,WAAcD,GAAG,KAAKJ,iBAAiB,CAACK,GAAD,CAAvC;AAAA,GAAtB,CADvB;;AAEA,MAAIH,mBAAJ,EAAyB;AACvB;AACA,QAAI,CAAC,+BAAcH,qBAAd,EAAqCE,gBAArC,CAAL,EAA6D;AAAA,uBACvB,4BAAU;AAC5CzD,QAAAA,KAAK,EAAE4C,WAAW,CAAC5C,KADyB;AAE5CC,QAAAA,MAAM,EAAE2C,WAAW,CAAC5C,KAFwB;AAG5CkC,QAAAA,MAAM,EAAE,CACN,CAACsB,iBAAiB,CAAC,CAAD,CAAlB,EAAuBA,iBAAiB,CAAC,CAAD,CAAxC,CADM,EAEN,CAACA,iBAAiB,CAAC,CAAD,CAAlB,EAAuBA,iBAAiB,CAAC,CAAD,CAAxC,CAFM;AAHoC,OAAV,CADuB;AAAA,UACpD5D,QADoD,cACpDA,QADoD;AAAA,UAC1CC,SAD0C,cAC1CA,SAD0C;AAAA,UAC/BC,IAD+B,cAC/BA,IAD+B;;AAU3D8C,MAAAA,WAAW,mCACNA,WADM;AAEThD,QAAAA,QAAQ,EAARA,QAFS;AAGTC,QAAAA,SAAS,EAATA;AAHS,SAMLwB,MAAM,CAACC,QAAP,CAAgBxB,IAAhB,IAAwB;AAACA,QAAAA,IAAI,EAAJA;AAAD,OAAxB,GAAiC,EAN5B,CAAX;AAQD;;AACD,WAAO8C,WAAP;AACD,GAxC0E,CA0C3E;;;AACA,MAAI,CAAC,+BAAcW,qBAAd,EAAqCE,gBAArC,CAAL,EAA6D;AAC3Db,IAAAA,WAAW,mCACNA,WADM;AAET/C,MAAAA,SAAS,EAAEc,KAAK,CAACd,SAFR;AAGTD,MAAAA,QAAQ,EAAEe,KAAK,CAACf,QAHP;AAITE,MAAAA,IAAI,EAAEa,KAAK,CAACb;AAJH,MAAX;AAMD;;AAED,SAAO8C,WAAP;AACD;;AAEM,SAASK,6BAAT,CAAuCtC,KAAvC,EAAkE;AACvE,SAAO,wBAAKA,KAAL,EAAY,CACjB,OADiB,EAEjB,QAFiB,EAGjB,MAHiB,EAIjB,OAJiB,EAKjB,SALiB,EAMjB,UANiB,EAOjB,WAPiB,EAQjB,YARiB,EASjB,SATiB,EAUjB,SAViB,EAWjB,WAXiB,CAAZ,CAAP;AAaD;AAED;;;AACA,IAAMmD,YAAY,GAAG,SAAfA,YAAe,CAAAC,GAAG;AAAA,SACtBC,MAAM,CAACC,OAAP,CAAeF,GAAf,EAAoBG,MAApB,CACE,UAACC,IAAD;AAAA;AAAA,QAAQC,CAAR;AAAA,QAAWrB,CAAX;;AAAA,2CAAuBoB,IAAvB,GAAiCpB,CAAC,KAAK5C,SAAN,wCAAoBiE,CAApB,EAAwBrB,CAAxB,IAA6B,EAA9D;AAAA,GADF,EAEE,EAFF,CADsB;AAAA,CAAxB;;AAMA,SAAS/B,cAAT,CAAwBqD,gBAAxB,EAAoDC,eAApD,EAAyF;AACvF,MAAIC,WAAW,mCACVF,gBADU,GAETP,YAAY,CAACQ,eAAD,CAAZ,IAAiC,EAFxB,CAAf,CADuF,CAMvF;;;AACA,MAAIC,WAAW,CAACrE,OAAZ,IAAuBqE,WAAW,CAACzE,IAAnC,IAA2CyE,WAAW,CAACzE,IAAZ,GAAmByE,WAAW,CAACrE,OAA9E,EAAuF;AACrFqE,IAAAA,WAAW,CAACzE,IAAZ,GAAmByE,WAAW,CAACrE,OAA/B;AACD,GATsF,CAUvF;;;AACA,MAAIqE,WAAW,CAACnE,OAAZ,IAAuBmE,WAAW,CAACzE,IAAnC,IAA2CyE,WAAW,CAACzE,IAAZ,GAAmByE,WAAW,CAACnE,OAA9E,EAAuF;AACrFmE,IAAAA,WAAW,CAACzE,IAAZ,GAAmByE,WAAW,CAACnE,OAA/B;AACD,GAbsF,CAcvF;;;AACA,MAAImE,WAAW,CAAClE,SAAZ,IAAyB,2BAAekE,WAAW,CAAClE,SAA3B,CAA7B,EAAoE;AAClE;AACAkE,IAAAA,WAAW,GAAGpB,2BAA2B,CAACkB,gBAAD,EAAmBE,WAAnB,CAAzC;AACD;;AAED,SAAOA,WAAP;AACD","sourcesContent":["// Copyright (c) 2023 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport 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 'lodash.pick';\n\nimport {getCenterAndZoomFromBounds, validateBounds, MAPBOX_TILE_SIZE} from '@kepler.gl/utils';\nimport {MapStateActions, ReceiveMapConfigPayload, ActionTypes} from '@kepler.gl/actions';\nimport {MapState, Bounds, Viewport} from '@kepler.gl/types';\n\n/**\n * Updaters for `mapState` reducer. Can be used in your root reducer to directly modify kepler.gl's state.\n * Read more about [Using updaters](../advanced-usage/using-updaters.md)\n * @public\n * @example\n *\n * import keplerGlReducer, {mapStateUpdaters} from 'kepler.gl/reducers';\n * // Root Reducer\n * const reducers = combineReducers({\n *  keplerGl: keplerGlReducer,\n *  app: appReducer\n * });\n *\n * const composedReducer = (state, action) => {\n *  switch (action.type) {\n *    // click button to close side panel\n *    case 'CLICK_BUTTON':\n *      return {\n *        ...state,\n *        keplerGl: {\n *          ...state.keplerGl,\n *          foo: {\n *             ...state.keplerGl.foo,\n *             mapState: mapStateUpdaters.fitBoundsUpdater(\n *               mapState, {payload: [127.34, 31.09, 127.56, 31.59]]}\n *             )\n *          }\n *        }\n *      };\n *  }\n *  return reducers(state, action);\n * };\n *\n * export default composedReducer;\n */\n/* eslint-disable no-unused-vars */\n// @ts-ignore\nconst mapStateUpdaters = null;\n/* eslint-enable no-unused-vars */\n\n/**\n * Default initial `mapState`\n * @memberof mapStateUpdaters\n * @constant\n * @property pitch Default: `0`\n * @property bearing Default: `0`\n * @property latitude Default: `37.75043`\n * @property longitude Default: `-122.34679`\n * @property zoom Default: `9`\n * @property dragRotate Default: `false`\n * @property width Default: `800`\n * @property height Default: `800`\n * @property minZoom: `undefined`,\n * @property maxZoom: `undefined`,\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  maxBounds: undefined,\n  isSplit: false,\n  isViewportSynced: true,\n  isZoomLocked: false,\n  splitMapViewports: []\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, mapIndex = 0} = action.payload;\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  });\n  if (!centerAndZoom) {\n    // bounds is invalid\n    return state;\n  }\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    ...(Number.isFinite(centerAndZoom.zoom) ? {zoom: centerAndZoom.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 = (\n  state: MapState,\n  action: MapStateActions.TogglePerspectiveUpdaterAction\n): MapState => {\n  const newState = {\n    ...state,\n    ...{\n      pitch: state.dragRotate ? 0 : 50,\n      bearing: state.dragRotate ? 0 : 24\n    },\n    dragRotate: !state.dragRotate\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 * 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    });\n  }\n\n  return {\n    ...mergedState,\n    // update width if `isSplit` has changed\n    ...getMapDimForSplitMap(mergedState.isSplit, state)\n  };\n};\n\n/**\n * Toggle between one or split maps\n * @memberof mapStateUpdaters\n * @public\n */\nexport const toggleSplitMapUpdater = (\n  state: MapState,\n  action: MapStateActions.ToggleSplitMapUpdaterAction\n): MapState => ({\n  ...state,\n  ...getMapDimForSplitMap(!state.isSplit, state),\n  isSplit: !state.isSplit,\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 * 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  // 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  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.width,\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    '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  // 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  // 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"]}

package/dist/map-state.d.ts

@@ -1,3 +1,75 @@
-export declare const mapStateReducerFactory: (initialState?: {}) => import("redux-actions").ReduxCompatibleReducer<import("@kepler.gl/types").MapState, import("@kepler.gl/types").MapState>;
-declare const _default: import("redux-actions").ReduxCompatibleReducer<import("@kepler.gl/types").MapState, import("@kepler.gl/types").MapState>;
+export declare const mapStateReducerFactory: (initialState?: {}) => import("redux-actions").ReduxCompatibleReducer<{
+    isViewportSynced: boolean;
+    isZoomLocked: boolean;
+    pitch: number;
+    bearing: number;
+    latitude: number;
+    longitude: number;
+    zoom: number;
+    dragRotate: boolean;
+    width: number;
+    height: number;
+    minZoom?: number | undefined;
+    maxZoom?: number | undefined;
+    maxBounds?: import("@kepler.gl/types").Bounds | undefined;
+    initialState?: any;
+    scale?: number | undefined;
+    isSplit: boolean;
+    splitMapViewports: import("@kepler.gl/types").Viewport[];
+}, {
+    isViewportSynced: boolean;
+    isZoomLocked: boolean;
+    pitch: number;
+    bearing: number;
+    latitude: number;
+    longitude: number;
+    zoom: number;
+    dragRotate: boolean;
+    width: number;
+    height: number;
+    minZoom?: number | undefined;
+    maxZoom?: number | undefined;
+    maxBounds?: import("@kepler.gl/types").Bounds | undefined;
+    initialState?: any;
+    scale?: number | undefined;
+    isSplit: boolean;
+    splitMapViewports: import("@kepler.gl/types").Viewport[];
+}>;
+declare const _default: import("redux-actions").ReduxCompatibleReducer<{
+    isViewportSynced: boolean;
+    isZoomLocked: boolean;
+    pitch: number;
+    bearing: number;
+    latitude: number;
+    longitude: number;
+    zoom: number;
+    dragRotate: boolean;
+    width: number;
+    height: number;
+    minZoom?: number | undefined;
+    maxZoom?: number | undefined;
+    maxBounds?: import("@kepler.gl/types").Bounds | undefined;
+    initialState?: any;
+    scale?: number | undefined;
+    isSplit: boolean;
+    splitMapViewports: import("@kepler.gl/types").Viewport[];
+}, {
+    isViewportSynced: boolean;
+    isZoomLocked: boolean;
+    pitch: number;
+    bearing: number;
+    latitude: number;
+    longitude: number;
+    zoom: number;
+    dragRotate: boolean;
+    width: number;
+    height: number;
+    minZoom?: number | undefined;
+    maxZoom?: number | undefined;
+    maxBounds?: import("@kepler.gl/types").Bounds | undefined;
+    initialState?: any;
+    scale?: number | undefined;
+    isSplit: boolean;
+    splitMapViewports: import("@kepler.gl/types").Viewport[];
+}>;
 export default _default;

package/dist/map-state.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
+// Copyright (c) 2023 Uber Technologies, Inc.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -47,7 +47,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
  * Important: Do not rename `actionHandler` or the assignment pattern of property value.
  * It is used to generate documentation
  */
-var actionHandler = (_actionHandler = {}, (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.UPDATE_MAP, mapStateUpdaters.updateMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.FIT_BOUNDS, mapStateUpdaters.fitBoundsUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_PERSPECTIVE, mapStateUpdaters.togglePerspectiveUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.RECEIVE_MAP_CONFIG, mapStateUpdaters.receiveMapConfigUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.RESET_MAP_CONFIG, mapStateUpdaters.resetMapConfigUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_SPLIT_MAP, mapStateUpdaters.toggleSplitMapUpdater), _actionHandler);
+var actionHandler = (_actionHandler = {}, (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.UPDATE_MAP, mapStateUpdaters.updateMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.FIT_BOUNDS, mapStateUpdaters.fitBoundsUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_PERSPECTIVE, mapStateUpdaters.togglePerspectiveUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.RECEIVE_MAP_CONFIG, mapStateUpdaters.receiveMapConfigUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.RESET_MAP_CONFIG, mapStateUpdaters.resetMapConfigUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_SPLIT_MAP, mapStateUpdaters.toggleSplitMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_SPLIT_MAP_VIEWPORT, mapStateUpdaters.toggleSplitMapViewportUpdater), _actionHandler);
 /* Reducer */
 
 var mapStateReducerFactory = function mapStateReducerFactory() {
@@ -64,4 +64,4 @@ exports.mapStateReducerFactory = mapStateReducerFactory;
 var _default = mapStateReducerFactory();
 
 exports["default"] = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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