@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/reducers/root.js

@@ -0,0 +1,218 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.provideInitialState = provideInitialState;
+exports["default"] = void 0;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _reduxActions = require("redux-actions");
+
+var _actionWrapper = require("../actions/action-wrapper");
+
+var _actions = require("../actions/actions");
+
+var _core = require("./core");
+
+var _actionTypes = _interopRequireDefault(require("../constants/action-types"));
+
+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; }
+
+// INITIAL_STATE
+var initialCoreState = {};
+
+function provideInitialState(initialState) {
+  var coreReducer = (0, _core.coreReducerFactory)(initialState);
+
+  var handleRegisterEntry = function handleRegisterEntry(state, _ref) {
+    var _ref$payload = _ref.payload,
+        id = _ref$payload.id,
+        mint = _ref$payload.mint,
+        mapboxApiAccessToken = _ref$payload.mapboxApiAccessToken,
+        mapboxApiUrl = _ref$payload.mapboxApiUrl,
+        mapStylesReplaceDefault = _ref$payload.mapStylesReplaceDefault,
+        initialUiState = _ref$payload.initialUiState;
+    // by default, always create a mint state even if the same id already exist
+    // if state.id exist and mint=false, keep the existing state
+    var previousState = state[id] && mint === false ? state[id] : undefined;
+    return _objectSpread(_objectSpread({}, state), {}, (0, _defineProperty2["default"])({}, id, coreReducer(previousState, (0, _actions.keplerGlInit)({
+      mapboxApiAccessToken: mapboxApiAccessToken,
+      mapboxApiUrl: mapboxApiUrl,
+      mapStylesReplaceDefault: mapStylesReplaceDefault,
+      initialUiState: initialUiState
+    }))));
+  };
+
+  var handleDeleteEntry = function handleDeleteEntry(state, _ref2) {
+    var id = _ref2.payload;
+    return Object.keys(state).reduce(function (accu, curr) {
+      return _objectSpread(_objectSpread({}, accu), curr === id ? {} : (0, _defineProperty2["default"])({}, curr, state[curr]));
+    }, {});
+  };
+
+  var handleRenameEntry = function handleRenameEntry(state, _ref4) {
+    var _ref4$payload = _ref4.payload,
+        oldId = _ref4$payload.oldId,
+        newId = _ref4$payload.newId;
+    return Object.keys(state).reduce(function (accu, curr) {
+      return _objectSpread(_objectSpread({}, accu), (0, _defineProperty2["default"])({}, curr === oldId ? newId : curr, state[curr]));
+    }, {});
+  };
+
+  return function () {
+    var _handlers;
+
+    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialCoreState;
+    var action = arguments.length > 1 ? arguments[1] : undefined;
+    // update child states
+    Object.keys(state).forEach(function (id) {
+      var updateItemState = coreReducer(state[id], (0, _actionWrapper._actionFor)(id, action));
+      state = (0, _actionWrapper._updateProperty)(state, id, updateItemState);
+    }); // perform additional state reducing (e.g. switch action.type etc...)
+
+    var handlers = (_handlers = {}, (0, _defineProperty2["default"])(_handlers, _actionTypes["default"].REGISTER_ENTRY, handleRegisterEntry), (0, _defineProperty2["default"])(_handlers, _actionTypes["default"].DELETE_ENTRY, handleDeleteEntry), (0, _defineProperty2["default"])(_handlers, _actionTypes["default"].RENAME_ENTRY, handleRenameEntry), _handlers); // @ts-ignore
+
+    return (0, _reduxActions.handleActions)(handlers, initialCoreState)(state, action);
+  };
+}
+
+var _keplerGlReducer = provideInitialState();
+
+function mergeInitialState() {
+  var saved = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var provided = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var keys = ['mapState', 'mapStyle', 'visState', 'uiState']; // shallow merge each reducer
+
+  return keys.reduce(function (accu, key) {
+    return _objectSpread(_objectSpread({}, accu), saved[key] && provided[key] ? (0, _defineProperty2["default"])({}, key, _objectSpread(_objectSpread({}, saved[key]), provided[key])) : (0, _defineProperty2["default"])({}, key, saved[key] || provided[key] || {}));
+  }, {});
+}
+
+function decorate(target) {
+  var savedInitialState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var targetInitialState = savedInitialState;
+  /**
+   * Returns a kepler.gl reducer that will also pass each action through additional reducers spiecified.
+   * The parameter should be either a reducer map or a reducer function.
+   * The state passed into the additional action handler is the instance state.
+   * It will include all the subreducers `visState`, `uiState`, `mapState` and `mapStyle`.
+   * `.plugin` is only meant to be called once when mounting the keplerGlReducer to the store.
+   * **Note** This is an advanced option to give you more freedom to modify the internal state of the kepler.gl instance.
+   * You should only use this to adding additional actions instead of replacing default actions.
+   *
+   * @mixin keplerGlReducer.plugin
+   * @memberof keplerGlReducer
+   * @param {Object|Function} customReducer - A reducer map or a reducer
+   * @public
+   * @example
+   * const myKeplerGlReducer = keplerGlReducer
+   *  .plugin({
+   *    // 1. as reducer map
+   *    HIDE_AND_SHOW_SIDE_PANEL: (state, action) => ({
+   *      ...state,
+   *      uiState: {
+   *        ...state.uiState,
+   *        readOnly: !state.uiState.readOnly
+   *      }
+   *    })
+   *  })
+   * .plugin(handleActions({
+   *   // 2. as reducer
+   *   'HIDE_MAP_CONTROLS': (state, action) => ({
+   *     ...state,
+   *     uiState: {
+   *       ...state.uiState,
+   *       mapControls: hiddenMapControl
+   *     }
+   *   })
+   * }, {}));
+   */
+
+  target.plugin = function plugin(customReducer) {
+    var _this = this;
+
+    if ((0, _typeof2["default"])(customReducer) === 'object') {
+      // if only provided a reducerMap, wrap it in a reducer
+      customReducer = (0, _reduxActions.handleActions)(customReducer, {});
+    } // use 'function' keyword to enable 'this'
+
+
+    return decorate(function () {
+      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      var nextState = _this(state, action); // for each entry in the staten
+
+
+      Object.keys(nextState).forEach(function (id) {
+        // update child states
+        nextState = (0, _actionWrapper._updateProperty)(nextState, id, customReducer(nextState[id], (0, _actionWrapper._actionFor)(id, action)));
+      });
+      return nextState;
+    });
+  };
+  /**
+   * Return a reducer that initiated with custom initial state.
+   * The parameter should be an object mapping from `subreducer` name to custom subreducer state,
+   * which will be shallow **merged** with default initial state.
+   *
+   * Default subreducer state:
+   *  - [`visState`](./vis-state.md#INITIAL_VIS_STATE)
+   *  - [`mapState`](./map-state.md#INITIAL_MAP_STATE)
+   *  - [`mapStyle`](./map-style.md#INITIAL_MAP_STYLE)
+   *  - [`uiState`](./ui-state.md#INITIAL_UI_STATE)
+   * @mixin keplerGlReducer.initialState
+   * @memberof keplerGlReducer
+   * @param {Object} iniSt - custom state to be merged with default initial state
+   * @public
+   * @example
+   * const myKeplerGlReducer = keplerGlReducer
+   *  .initialState({
+   *    uiState: {readOnly: true}
+   *  });
+   */
+
+
+  target.initialState = function initialState(iniSt) {
+    var merged = mergeInitialState(targetInitialState, iniSt);
+    var targetReducer = provideInitialState(merged);
+    return decorate(targetReducer, merged);
+  };
+
+  return target;
+}
+/**
+ * Kepler.gl reducer to be mounted to your store. You can mount `keplerGlReducer` at property `keplerGl`, if you choose
+ * to mount it at another address e.g. `foo` you will need to specify it when you mount `KeplerGl` component in your app with `getState: state => state.foo`
+ * @public
+ * @example
+ * import keplerGlReducer from 'kepler.gl/reducers';
+ * import {createStore, combineReducers, applyMiddleware, compose} from 'redux';
+ * import {taskMiddleware} from 'react-palm/tasks';
+ *
+ * const initialState = {};
+ * const reducers = combineReducers({
+ *   // <-- mount kepler.gl reducer in your app
+ *   keplerGl: keplerGlReducer,
+ *
+ *   // Your other reducers here
+ *   app: appReducer
+ * });
+ *
+ * // using createStore
+ * export default createStore(reducer, initialState, applyMiddleware(taskMiddleware));
+ */
+
+
+var keplerGlReducer = decorate(_keplerGlReducer);
+var _default = keplerGlReducer;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/reducers/root.js"],"names":["initialCoreState","provideInitialState","initialState","coreReducer","handleRegisterEntry","state","payload","id","mint","mapboxApiAccessToken","mapboxApiUrl","mapStylesReplaceDefault","initialUiState","previousState","undefined","handleDeleteEntry","Object","keys","reduce","accu","curr","handleRenameEntry","oldId","newId","action","forEach","updateItemState","handlers","ActionTypes","REGISTER_ENTRY","DELETE_ENTRY","RENAME_ENTRY","_keplerGlReducer","mergeInitialState","saved","provided","key","decorate","target","savedInitialState","targetInitialState","plugin","customReducer","nextState","iniSt","merged","targetReducer","keplerGlReducer"],"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 {handleActions} from 'redux-actions';\n\nimport {_actionFor, _updateProperty} from '../actions/action-wrapper';\nimport {keplerGlInit} from '../actions/actions';\nimport {coreReducerFactory} from './core';\nimport ActionTypes from 'constants/action-types';\n\n// INITIAL_STATE\nconst initialCoreState = {};\n\nexport function provideInitialState(initialState) {\n  const coreReducer = coreReducerFactory(initialState);\n\n  const handleRegisterEntry = (\n    state,\n    {\n      payload: {\n        id,\n        mint,\n        mapboxApiAccessToken,\n        mapboxApiUrl,\n        mapStylesReplaceDefault,\n        initialUiState\n      }\n    }\n  ) => {\n    // by default, always create a mint state even if the same id already exist\n    // if state.id exist and mint=false, keep the existing state\n    const previousState = state[id] && mint === false ? state[id] : undefined;\n\n    return {\n      // register entry to kepler.gl passing in mapbox config to mapStyle\n      ...state,\n      [id]: coreReducer(\n        previousState,\n        keplerGlInit({mapboxApiAccessToken, mapboxApiUrl, mapStylesReplaceDefault, initialUiState})\n      )\n    };\n  };\n\n  const handleDeleteEntry = (state, {payload: id}) =>\n    Object.keys(state).reduce(\n      (accu, curr) => ({\n        ...accu,\n        ...(curr === id ? {} : {[curr]: state[curr]})\n      }),\n      {}\n    );\n\n  const handleRenameEntry = (state, {payload: {oldId, newId}}) =>\n    Object.keys(state).reduce(\n      (accu, curr) => ({\n        ...accu,\n        ...{[curr === oldId ? newId : curr]: state[curr]}\n      }),\n      {}\n    );\n\n  return (state = initialCoreState, action) => {\n    // update child states\n    Object.keys(state).forEach(id => {\n      const updateItemState = coreReducer(state[id], _actionFor(id, action));\n      state = _updateProperty(state, id, updateItemState);\n    });\n\n    // perform additional state reducing (e.g. switch action.type etc...)\n    const handlers = {\n      [ActionTypes.REGISTER_ENTRY]: handleRegisterEntry,\n      [ActionTypes.DELETE_ENTRY]: handleDeleteEntry,\n      [ActionTypes.RENAME_ENTRY]: handleRenameEntry\n    };\n\n    // @ts-ignore\n    return handleActions(handlers, initialCoreState)(state, action);\n  };\n}\n\nconst _keplerGlReducer = provideInitialState();\n\nfunction mergeInitialState(saved = {}, provided = {}) {\n  const keys = ['mapState', 'mapStyle', 'visState', 'uiState'];\n\n  // shallow merge each reducer\n  return keys.reduce(\n    (accu, key) => ({\n      ...accu,\n      ...(saved[key] && provided[key]\n        ? {[key]: {...saved[key], ...provided[key]}}\n        : {[key]: saved[key] || provided[key] || {}})\n    }),\n    {}\n  );\n}\n\nfunction decorate(target, savedInitialState = {}) {\n  const targetInitialState = savedInitialState;\n\n  /**\n   * Returns a kepler.gl reducer that will also pass each action through additional reducers spiecified.\n   * The parameter should be either a reducer map or a reducer function.\n   * The state passed into the additional action handler is the instance state.\n   * It will include all the subreducers `visState`, `uiState`, `mapState` and `mapStyle`.\n   * `.plugin` is only meant to be called once when mounting the keplerGlReducer to the store.\n   * **Note** This is an advanced option to give you more freedom to modify the internal state of the kepler.gl instance.\n   * You should only use this to adding additional actions instead of replacing default actions.\n   *\n   * @mixin keplerGlReducer.plugin\n   * @memberof keplerGlReducer\n   * @param {Object|Function} customReducer - A reducer map or a reducer\n   * @public\n   * @example\n   * const myKeplerGlReducer = keplerGlReducer\n   *  .plugin({\n   *    // 1. as reducer map\n   *    HIDE_AND_SHOW_SIDE_PANEL: (state, action) => ({\n   *      ...state,\n   *      uiState: {\n   *        ...state.uiState,\n   *        readOnly: !state.uiState.readOnly\n   *      }\n   *    })\n   *  })\n   * .plugin(handleActions({\n   *   // 2. as reducer\n   *   'HIDE_MAP_CONTROLS': (state, action) => ({\n   *     ...state,\n   *     uiState: {\n   *       ...state.uiState,\n   *       mapControls: hiddenMapControl\n   *     }\n   *   })\n   * }, {}));\n   */\n  target.plugin = function plugin(customReducer) {\n    if (typeof customReducer === 'object') {\n      // if only provided a reducerMap, wrap it in a reducer\n      customReducer = handleActions(customReducer, {});\n    }\n\n    // use 'function' keyword to enable 'this'\n    return decorate((state = {}, action = {}) => {\n      let nextState = this(state, action);\n\n      // for each entry in the staten\n      Object.keys(nextState).forEach(id => {\n        // update child states\n        nextState = _updateProperty(\n          nextState,\n          id,\n          customReducer(nextState[id], _actionFor(id, action))\n        );\n      });\n\n      return nextState;\n    });\n  };\n\n  /**\n   * Return a reducer that initiated with custom initial state.\n   * The parameter should be an object mapping from `subreducer` name to custom subreducer state,\n   * which will be shallow **merged** with default initial state.\n   *\n   * Default subreducer state:\n   *  - [`visState`](./vis-state.md#INITIAL_VIS_STATE)\n   *  - [`mapState`](./map-state.md#INITIAL_MAP_STATE)\n   *  - [`mapStyle`](./map-style.md#INITIAL_MAP_STYLE)\n   *  - [`uiState`](./ui-state.md#INITIAL_UI_STATE)\n   * @mixin keplerGlReducer.initialState\n   * @memberof keplerGlReducer\n   * @param {Object} iniSt - custom state to be merged with default initial state\n   * @public\n   * @example\n   * const myKeplerGlReducer = keplerGlReducer\n   *  .initialState({\n   *    uiState: {readOnly: true}\n   *  });\n   */\n  target.initialState = function initialState(iniSt) {\n    const merged = mergeInitialState(targetInitialState, iniSt);\n    const targetReducer = provideInitialState(merged);\n\n    return decorate(targetReducer, merged);\n  };\n\n  return target;\n}\n\n/**\n * Kepler.gl reducer to be mounted to your store. You can mount `keplerGlReducer` at property `keplerGl`, if you choose\n * to mount it at another address e.g. `foo` you will need to specify it when you mount `KeplerGl` component in your app with `getState: state => state.foo`\n * @public\n * @example\n * import keplerGlReducer from 'kepler.gl/reducers';\n * import {createStore, combineReducers, applyMiddleware, compose} from 'redux';\n * import {taskMiddleware} from 'react-palm/tasks';\n *\n * const initialState = {};\n * const reducers = combineReducers({\n *   // <-- mount kepler.gl reducer in your app\n *   keplerGl: keplerGlReducer,\n *\n *   // Your other reducers here\n *   app: appReducer\n * });\n *\n * // using createStore\n * export default createStore(reducer, initialState, applyMiddleware(taskMiddleware));\n */\nconst keplerGlReducer = decorate(_keplerGlReducer);\nexport default keplerGlReducer;\n"]}