@kepler.gl/reducers 3.0.0-alpha.0

package/dist/map-state-updaters.js

@@ -0,0 +1,250 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+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;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+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; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/**
+ * 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 no-unused-vars */
+// @ts-ignore
+var mapStateUpdaters = null;
+/* eslint-enable 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 isSplit Default: `false`
+ * @public
+ */
+
+var INITIAL_MAP_STATE = {
+  pitch: 0,
+  bearing: 0,
+  latitude: 37.75043,
+  longitude: -122.34679,
+  zoom: 9,
+  dragRotate: false,
+  width: 800,
+  height: 800,
+  isSplit: false
+};
+/* Updaters */
+
+/**
+ * Update map viewport
+ * @memberof mapStateUpdaters
+ * @public
+ */
+
+exports.INITIAL_MAP_STATE = INITIAL_MAP_STATE;
+
+var updateMapUpdater = function updateMapUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), action.payload || {});
+};
+/**
+ * Fit map viewport to bounds
+ * @memberof mapStateUpdaters
+ * @public
+ */
+
+
+exports.updateMapUpdater = updateMapUpdater;
+
+var fitBoundsUpdater = function fitBoundsUpdater(state, action) {
+  var centerAndZoom = (0, _utils.getCenterAndZoomFromBounds)(action.payload, {
+    width: state.width,
+    height: state.height
+  });
+
+  if (!centerAndZoom) {
+    // bounds is invalid
+    return state;
+  }
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    latitude: centerAndZoom.center[1],
+    longitude: centerAndZoom.center[0]
+  }, Number.isFinite(centerAndZoom.zoom) ? {
+    zoom: centerAndZoom.zoom
+  } : {});
+};
+/**
+ * Toggle between 3d and 2d map.
+ * @memberof mapStateUpdaters
+ * @public
+ */
+
+
+exports.fitBoundsUpdater = fitBoundsUpdater;
+
+var togglePerspectiveUpdater = function togglePerspectiveUpdater(state, action) {
+  return _objectSpread(_objectSpread(_objectSpread({}, state), {
+    pitch: state.dragRotate ? 0 : 50,
+    bearing: state.dragRotate ? 0 : 24
+  }), {}, {
+    dragRotate: !state.dragRotate
+  });
+};
+/**
+ * reset mapState to initial State
+ * @memberof mapStateUpdaters
+ * @public
+ */
+
+
+exports.togglePerspectiveUpdater = togglePerspectiveUpdater;
+
+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
+ */
+
+
+exports.resetMapConfigUpdater = resetMapConfigUpdater;
+
+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;
+
+  var _ref2 = config || {},
+      mapState = _ref2.mapState; // merged received mapstate with previous state
+
+
+  var mergedState = _objectSpread(_objectSpread({}, state), mapState); // if center map
+  // center map will override mapState config
+
+
+  if (options.centerMap && bounds) {
+    mergedState = fitBoundsUpdater(mergedState, {
+      payload: bounds
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, mergedState), getMapDimForSplitMap(mergedState.isSplit, state));
+};
+/**
+ * Toggle between one or split maps
+ * @memberof mapStateUpdaters
+ * @public
+ */
+
+
+exports.receiveMapConfigUpdater = receiveMapConfigUpdater;
+
+var toggleSplitMapUpdater = function toggleSplitMapUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    isSplit: !state.isSplit
+  }, getMapDimForSplitMap(!state.isSplit, state));
+}; // Helpers
+
+
+exports.toggleSplitMapUpdater = toggleSplitMapUpdater;
+
+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 {};
+  }
+
+  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
+  };
+}
+//# 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"]}

package/dist/map-state.d.ts

@@ -0,0 +1,3 @@
+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 default _default;

package/dist/map-state.js

@@ -0,0 +1,67 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.mapStateReducerFactory = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _reduxActions = require("redux-actions");
+
+var _actions = require("@kepler.gl/actions");
+
+var mapStateUpdaters = _interopRequireWildcard(require("./map-state-updaters"));
+
+var _actionHandler;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/**
+ * 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);
+/* Reducer */
+
+var mapStateReducerFactory = function mapStateReducerFactory() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (// @ts-expect-error
+    (0, _reduxActions.handleActions)(actionHandler, _objectSpread(_objectSpread(_objectSpread({}, mapStateUpdaters.INITIAL_MAP_STATE), initialState), {}, {
+      initialState: initialState
+    }))
+  );
+};
+
+exports.mapStateReducerFactory = mapStateReducerFactory;
+
+var _default = mapStateReducerFactory();
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9tYXAtc3RhdGUudHMiXSwibmFtZXMiOlsiYWN0aW9uSGFuZGxlciIsIkFjdGlvblR5cGVzIiwiVVBEQVRFX01BUCIsIm1hcFN0YXRlVXBkYXRlcnMiLCJ1cGRhdGVNYXBVcGRhdGVyIiwiRklUX0JPVU5EUyIsImZpdEJvdW5kc1VwZGF0ZXIiLCJUT0dHTEVfUEVSU1BFQ1RJVkUiLCJ0b2dnbGVQZXJzcGVjdGl2ZVVwZGF0ZXIiLCJSRUNFSVZFX01BUF9DT05GSUciLCJyZWNlaXZlTWFwQ29uZmlnVXBkYXRlciIsIlJFU0VUX01BUF9DT05GSUciLCJyZXNldE1hcENvbmZpZ1VwZGF0ZXIiLCJUT0dHTEVfU1BMSVRfTUFQIiwidG9nZ2xlU3BsaXRNYXBVcGRhdGVyIiwibWFwU3RhdGVSZWR1Y2VyRmFjdG9yeSIsImluaXRpYWxTdGF0ZSIsIklOSVRJQUxfTUFQX1NUQVRFIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7O0FBb0JBOztBQUNBOztBQUNBOzs7Ozs7OztBQUVBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsSUFBTUEsYUFBYSwwRUFDaEJDLHFCQUFZQyxVQURJLEVBQ1NDLGdCQUFnQixDQUFDQyxnQkFEMUIsb0RBRWhCSCxxQkFBWUksVUFGSSxFQUVTRixnQkFBZ0IsQ0FBQ0csZ0JBRjFCLG9EQUdoQkwscUJBQVlNLGtCQUhJLEVBR2lCSixnQkFBZ0IsQ0FBQ0ssd0JBSGxDLG9EQUloQlAscUJBQVlRLGtCQUpJLEVBSWlCTixnQkFBZ0IsQ0FBQ08sdUJBSmxDLG9EQUtoQlQscUJBQVlVLGdCQUxJLEVBS2VSLGdCQUFnQixDQUFDUyxxQkFMaEMsb0RBTWhCWCxxQkFBWVksZ0JBTkksRUFNZVYsZ0JBQWdCLENBQUNXLHFCQU5oQyxrQkFBbkI7QUFTQTs7QUFDTyxJQUFNQyxzQkFBc0IsR0FBRyxTQUF6QkEsc0JBQXlCO0FBQUEsTUFBQ0MsWUFBRCx1RUFBZ0IsRUFBaEI7QUFBQSxTQUNwQztBQUNBLHFDQUFjaEIsYUFBZCxnREFDS0csZ0JBQWdCLENBQUNjLGlCQUR0QixHQUVLRCxZQUZMO0FBR0VBLE1BQUFBLFlBQVksRUFBWkE7QUFIRjtBQUZvQztBQUFBLENBQS9COzs7O2VBUVFELHNCQUFzQixFIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChjKSAyMDIyIFViZXIgVGVjaG5vbG9naWVzLCBJbmMuXG4vL1xuLy8gUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weVxuLy8gb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgXCJTb2Z0d2FyZVwiKSwgdG8gZGVhbFxuLy8gaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0c1xuLy8gdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbFxuLy8gY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzXG4vLyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOlxuLy9cbi8vIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluXG4vLyBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS5cbi8vXG4vLyBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgXCJBUyBJU1wiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SXG4vLyBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSxcbi8vIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRVxuLy8gQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUlxuLy8gTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSxcbi8vIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU5cbi8vIFRIRSBTT0ZUV0FSRS5cblxuaW1wb3J0IHtoYW5kbGVBY3Rpb25zfSBmcm9tICdyZWR1eC1hY3Rpb25zJztcbmltcG9ydCB7QWN0aW9uVHlwZXN9IGZyb20gJ0BrZXBsZXIuZ2wvYWN0aW9ucyc7XG5pbXBvcnQgKiBhcyBtYXBTdGF0ZVVwZGF0ZXJzIGZyb20gJy4vbWFwLXN0YXRlLXVwZGF0ZXJzJztcblxuLyoqXG4gKiBJbXBvcnRhbnQ6IERvIG5vdCByZW5hbWUgYGFjdGlvbkhhbmRsZXJgIG9yIHRoZSBhc3NpZ25tZW50IHBhdHRlcm4gb2YgcHJvcGVydHkgdmFsdWUuXG4gKiBJdCBpcyB1c2VkIHRvIGdlbmVyYXRlIGRvY3VtZW50YXRpb25cbiAqL1xuY29uc3QgYWN0aW9uSGFuZGxlciA9IHtcbiAgW0FjdGlvblR5cGVzLlVQREFURV9NQVBdOiBtYXBTdGF0ZVVwZGF0ZXJzLnVwZGF0ZU1hcFVwZGF0ZXIsXG4gIFtBY3Rpb25UeXBlcy5GSVRfQk9VTkRTXTogbWFwU3RhdGVVcGRhdGVycy5maXRCb3VuZHNVcGRhdGVyLFxuICBbQWN0aW9uVHlwZXMuVE9HR0xFX1BFUlNQRUNUSVZFXTogbWFwU3RhdGVVcGRhdGVycy50b2dnbGVQZXJzcGVjdGl2ZVVwZGF0ZXIsXG4gIFtBY3Rpb25UeXBlcy5SRUNFSVZFX01BUF9DT05GSUddOiBtYXBTdGF0ZVVwZGF0ZXJzLnJlY2VpdmVNYXBDb25maWdVcGRhdGVyLFxuICBbQWN0aW9uVHlwZXMuUkVTRVRfTUFQX0NPTkZJR106IG1hcFN0YXRlVXBkYXRlcnMucmVzZXRNYXBDb25maWdVcGRhdGVyLFxuICBbQWN0aW9uVHlwZXMuVE9HR0xFX1NQTElUX01BUF06IG1hcFN0YXRlVXBkYXRlcnMudG9nZ2xlU3BsaXRNYXBVcGRhdGVyXG59O1xuXG4vKiBSZWR1Y2VyICovXG5leHBvcnQgY29uc3QgbWFwU3RhdGVSZWR1Y2VyRmFjdG9yeSA9IChpbml0aWFsU3RhdGUgPSB7fSkgPT5cbiAgLy8gQHRzLWV4cGVjdC1lcnJvclxuICBoYW5kbGVBY3Rpb25zKGFjdGlvbkhhbmRsZXIsIHtcbiAgICAuLi5tYXBTdGF0ZVVwZGF0ZXJzLklOSVRJQUxfTUFQX1NUQVRFLFxuICAgIC4uLmluaXRpYWxTdGF0ZSxcbiAgICBpbml0aWFsU3RhdGVcbiAgfSk7XG5cbmV4cG9ydCBkZWZhdWx0IG1hcFN0YXRlUmVkdWNlckZhY3RvcnkoKTtcbiJdfQ==

package/dist/map-style-updaters.d.ts

@@ -0,0 +1,173 @@
+import { RGBColor, LayerGroup, MapStyles, InputStyle, VisibleLayerGroups } from '@kepler.gl/types';
+import { ActionTypes, ReceiveMapConfigPayload, KeplerGlInitPayload, MapStyleActions } from '@kepler.gl/actions';
+export declare type MapboxStyleUrl = string;
+export declare type MapStyle = {
+    styleType: string;
+    visibleLayerGroups: VisibleLayerGroups;
+    topLayerGroups: VisibleLayerGroups;
+    mapStyles: MapStyles;
+    mapboxApiAccessToken: string | null;
+    mapboxApiUrl: string;
+    mapStylesReplaceDefault: boolean;
+    inputStyle: InputStyle;
+    threeDBuildingColor: RGBColor;
+    custom3DBuildingColor: boolean;
+    bottomMapStyle: any;
+    topMapStyle: any;
+    initialState?: MapStyle;
+};
+/**
+ * Default initial `mapStyle`
+ * @memberof mapStyleUpdaters
+ * @constant
+ * @property styleType - Default: `'dark'`
+ * @property visibleLayerGroups - Default: `{}`
+ * @property topLayerGroups - Default: `{}`
+ * @property mapStyles - mapping from style key to style object
+ * @property mapboxApiAccessToken - Default: `null`
+ * @Property mapboxApiUrl - Default null
+ * @Property mapStylesReplaceDefault - Default: `false`
+ * @property inputStyle - Default: `{}`
+ * @property threeDBuildingColor - Default: `[r, g, b]`
+ * @public
+ */
+export declare const INITIAL_MAP_STYLE: MapStyle;
+interface GetMapStylesParam {
+    styleType: string;
+    visibleLayerGroups: {
+        [id: string]: LayerGroup | boolean;
+    };
+    topLayerGroups: {
+        [id: string]: LayerGroup | boolean;
+    };
+    mapStyles: {
+        [id: string]: any;
+    };
+}
+/**
+ * Create two map styles from preset map style, one for top map one for bottom
+ *
+ * @param {string} styleType - current map style
+ * @param {Object} visibleLayerGroups - visible layers of bottom map
+ * @param {Object} topLayerGroups - visible layers of top map
+ * @param {Object} mapStyles - a dictionary of all map styles
+ * @returns {Object} bottomMapStyle | topMapStyle | isRaster
+ */
+export declare function getMapStyles({ styleType, visibleLayerGroups, topLayerGroups, mapStyles }: GetMapStylesParam): {
+    bottomMapStyle?: undefined;
+    topMapStyle?: undefined;
+    editable?: undefined;
+} | {
+    bottomMapStyle: any;
+    topMapStyle: {
+        layers: any;
+        constructor?: Function | undefined;
+        toString?: (() => string) | undefined;
+        toLocaleString?: (() => string) | undefined;
+        valueOf?: (() => Object) | undefined;
+        hasOwnProperty?: ((v: PropertyKey) => boolean) | undefined;
+        isPrototypeOf?: ((v: Object) => boolean) | undefined;
+        propertyIsEnumerable?: ((v: PropertyKey) => boolean) | undefined;
+    } | null;
+    editable: number;
+};
+/**
+ * Propagate `mapStyle` reducer with `mapboxApiAccessToken` and `mapStylesReplaceDefault`.
+ * if mapStylesReplaceDefault is true mapStyles is emptied; loadMapStylesUpdater() will
+ * populate mapStyles.
+ *
+ * @memberof mapStyleUpdaters
+ * @public
+ */
+export declare const initMapStyleUpdater: (state: MapStyle, { payload }: {
+    type?: "@@kepler.gl/INIT" | undefined;
+    payload: KeplerGlInitPayload;
+}) => MapStyle;
+/**
+ * Update `visibleLayerGroups`to change layer group visibility
+ * @memberof mapStyleUpdaters
+ * @public
+ */
+export declare const mapConfigChangeUpdater: (state: MapStyle, action: MapStyleActions.MapConfigChangeUpdaterAction) => MapStyle;
+/**
+ * Change to another map style. The selected style should already been loaded into `mapStyle.mapStyles`
+ * @memberof mapStyleUpdaters
+ * @public
+ */
+export declare const mapStyleChangeUpdater: (state: MapStyle, { payload: styleType }: MapStyleActions.MapStyleChangeUpdaterAction) => MapStyle;
+/**
+ * Callback when load map style success
+ * @memberof mapStyleUpdaters
+ * @public
+ */
+export declare const loadMapStylesUpdater: (state: MapStyle, action: MapStyleActions.LoadMapStylesUpdaterAction) => MapStyle;
+/**
+ * Callback when load map style error
+ * @memberof mapStyleUpdaters
+ * @public
+ */
+export declare const loadMapStyleErrUpdater: (state: MapStyle, action: MapStyleActions.LoadMapStyleErrUpdaterAction) => MapStyle;
+/**
+ * @memberof mapStyleUpdaters
+ * @public
+ */
+export declare const requestMapStylesUpdater: (state: MapStyle, { payload: mapStyles }: MapStyleActions.RequestMapStylesUpdaterAction) => MapStyle;
+/**
+ * Load map style object when pass in saved map config
+ * @memberof mapStyleUpdaters
+ * @param state `mapStyle`
+ * @param action
+ * @param action.payload saved map config `{mapStyle, visState, mapState}`
+ * @returns nextState or `react-pam` tasks to load map style object
+ */
+export declare const receiveMapConfigUpdater: (state: MapStyle, { payload: { config } }: {
+    type?: typeof ActionTypes.RECEIVE_MAP_CONFIG;
+    payload: ReceiveMapConfigPayload;
+}) => MapStyle;
+/**
+ * Reset map style config to initial state
+ * @memberof mapStyleUpdaters
+ * @param state `mapStyle`
+ * @returns nextState
+ * @public
+ */
+export declare const resetMapConfigMapStyleUpdater: (state: MapStyle) => MapStyle;
+/**
+ * Callback when a custom map style object is received
+ * @memberof mapStyleUpdaters
+ * @public
+ */
+export declare const loadCustomMapStyleUpdater: (state: MapStyle, { payload: { icon, style, error } }: MapStyleActions.LoadCustomMapStyleUpdaterAction) => MapStyle;
+/**
+ * Input a custom map style object
+ * @memberof mapStyleUpdaters
+ * @public
+ */
+export declare const inputMapStyleUpdater: (state: MapStyle, { payload: { inputStyle, mapState } }: MapStyleActions.InputMapStyleUpdaterAction) => MapStyle;
+/**
+ * Add map style from user input to reducer and set it to current style
+ * This action is called when user click confirm after putting in a valid style url in the custom map style dialog.
+ * It should not be called from outside kepler.gl without a valid `inputStyle` in the `mapStyle` reducer.
+ * @memberof mapStyleUpdaters
+ */
+export declare const addCustomMapStyleUpdater: (state: MapStyle) => MapStyle;
+/**
+ * Updates 3d building color
+ * @memberof mapStyleUpdaters
+ */
+export declare const set3dBuildingColorUpdater: (state: MapStyle, { payload: color }: MapStyleActions.Set3dBuildingColorUpdaterAction) => MapStyle;
+/**
+ * Return the initial input style
+ * @return Object
+ */
+export declare function getInitialInputStyle(): {
+    accessToken: null;
+    error: boolean;
+    isValid: boolean;
+    label: null;
+    style: null;
+    url: null;
+    icon: null;
+    custom: boolean;
+};
+export {};