@kepler.gl/reducers 3.0.0-alpha.0

package/dist/combined-updaters.d.ts

@@ -0,0 +1,50 @@
+import { MapState, UiState, AddDataToMapPayload } from '@kepler.gl/types';
+import { MapStyle } from './map-style-updaters';
+import { ProviderState } from './provider-state-updaters';
+import { loadFilesSuccessUpdaterAction } from '@kepler.gl/actions';
+import { VisState } from '@kepler.gl/schemas';
+export declare type KeplerGlState = {
+    visState: VisState;
+    mapState: MapState;
+    mapStyle: MapStyle;
+    uiState: UiState;
+    providerState: ProviderState;
+};
+export declare const isValidConfig: (config: any) => unknown;
+export declare const defaultAddDataToMapOptions: {
+    centerMap: boolean;
+    keepExistingConfig: boolean;
+    autoCreateLayers: boolean;
+};
+/**
+ * Combine data and full configuration update in a single action
+ *
+ * @memberof combinedUpdaters
+ * @param {Object} state kepler.gl instance state, containing all subreducer state
+ * @param {Object} action
+ * @param {Object} action.payload `{datasets, options, config}`
+ * @param action.payload.datasets - ***required** datasets can be a dataset or an array of datasets
+ * Each dataset object needs to have `info` and `data` property.
+ * @param [action.payload.options] option object `{centerMap: true}`
+ * @param [action.payload.config] map config
+ * @param [action.payload.info] map info contains title and description
+ * @returns nextState
+ *
+ * @typedef {Object} Dataset
+ * @property info -info of a dataset
+ * @property info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.
+ * @property info.label - A display name of this dataset
+ * @property data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`
+ * @property data.fields - ***required** Array of fields,
+ * @property data.fields.name - ***required** Name of the field,
+ * @property data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`
+ *
+ * @public
+ */
+export declare const addDataToMapUpdater: (state: KeplerGlState, { payload }: {
+    payload: AddDataToMapPayload;
+}) => KeplerGlState;
+export declare const loadFilesSuccessUpdater: (state: KeplerGlState, action: loadFilesSuccessUpdaterAction) => KeplerGlState;
+export declare const addDataToMapComposed: (state: KeplerGlState, { payload }: {
+    payload: AddDataToMapPayload;
+}) => KeplerGlState;

package/dist/combined-updaters.js

@@ -0,0 +1,212 @@
+// 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.addDataToMapComposed = exports.loadFilesSuccessUpdater = exports.addDataToMapUpdater = exports.defaultAddDataToMapOptions = exports.isValidConfig = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _uiStateUpdaters = require("./ui-state-updaters");
+
+var _visStateUpdaters = require("./vis-state-updaters");
+
+var _mapStateUpdaters = require("./map-state-updaters");
+
+var _mapStyleUpdaters = require("./map-style-updaters");
+
+var _processors = require("@kepler.gl/processors");
+
+var _composerHelpers = require("./composer-helpers");
+
+var _utils = require("@kepler.gl/utils");
+
+var _dataUtils = require("./data-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; }
+
+// compose action to apply result multiple reducers, with the output of one
+
+/**
+ * Some actions will affect the entire kepler.lg instance state.
+ * The updaters for these actions is exported as `combinedUpdaters`. These updater take the entire instance state
+ * as the first argument. Read more about [Using updaters](../advanced-usage/using-updaters.md)
+ * @public
+ * @example
+ *
+ * import keplerGlReducer, {combinedUpdaters} from 'kepler.gl/reducers';
+ * // Root Reducer
+ * const reducers = combineReducers({
+ *  keplerGl: keplerGlReducer,
+ *  app: appReducer
+ * });
+ *
+ * const composedReducer = (state, action) => {
+ *  switch (action.type) {
+ *    // add data to map after receiving data from remote sources
+ *    case 'LOAD_REMOTE_RESOURCE_SUCCESS':
+ *      return {
+ *        ...state,
+ *        keplerGl: {
+ *          ...state.keplerGl,
+ *          // pass in kepler.gl instance state to combinedUpdaters
+ *          map:  combinedUpdaters.addDataToMapUpdater(
+ *           state.keplerGl.map,
+ *           {
+ *             payload: {
+ *               datasets: action.datasets,
+ *               options: {readOnly: true},
+ *               config: action.config
+ *              }
+ *            }
+ *          )
+ *        }
+ *      };
+ *  }
+ *  return reducers(state, action);
+ * };
+ *
+ * export default composedReducer;
+ */
+
+/* eslint-disable no-unused-vars */
+// @ts-ignore
+var combinedUpdaters = null;
+/* eslint-enable no-unused-vars */
+
+var isValidConfig = function isValidConfig(config) {
+  return (0, _utils.isPlainObject)(config) && (0, _utils.isPlainObject)(config.config) && config.version;
+};
+
+exports.isValidConfig = isValidConfig;
+var defaultAddDataToMapOptions = {
+  centerMap: true,
+  keepExistingConfig: false,
+  autoCreateLayers: true
+};
+/**
+ * Combine data and full configuration update in a single action
+ *
+ * @memberof combinedUpdaters
+ * @param {Object} state kepler.gl instance state, containing all subreducer state
+ * @param {Object} action
+ * @param {Object} action.payload `{datasets, options, config}`
+ * @param action.payload.datasets - ***required** datasets can be a dataset or an array of datasets
+ * Each dataset object needs to have `info` and `data` property.
+ * @param [action.payload.options] option object `{centerMap: true}`
+ * @param [action.payload.config] map config
+ * @param [action.payload.info] map info contains title and description
+ * @returns nextState
+ *
+ * @typedef {Object} Dataset
+ * @property info -info of a dataset
+ * @property info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.
+ * @property info.label - A display name of this dataset
+ * @property data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`
+ * @property data.fields - ***required** Array of fields,
+ * @property data.fields.name - ***required** Name of the field,
+ * @property data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`
+ *
+ * @public
+ */
+
+exports.defaultAddDataToMapOptions = defaultAddDataToMapOptions;
+
+var addDataToMapUpdater = function addDataToMapUpdater(state, _ref) {
+  var payload = _ref.payload;
+  var datasets = payload.datasets,
+      config = payload.config,
+      info = payload.info;
+
+  var options = _objectSpread(_objectSpread({}, defaultAddDataToMapOptions), payload.options); // @ts-expect-error
+
+
+  var parsedConfig = config;
+
+  if (isValidConfig(config)) {
+    // if passed in saved config
+    // @ts-expect-error
+    parsedConfig = state.visState.schema.parseSavedConfig(config);
+  }
+
+  var oldLayers = state.visState.layers;
+
+  var filterNewlyAddedLayers = function filterNewlyAddedLayers(layers) {
+    return layers.filter(function (nl) {
+      return !oldLayers.find(function (ol) {
+        return ol === nl;
+      });
+    });
+  }; // Returns undefined if not found, to make typescript happy
+
+
+  var findMapBoundsIfCentered = function findMapBoundsIfCentered(layers) {
+    var bounds = options.centerMap && (0, _dataUtils.findMapBounds)(layers);
+    return bounds ? bounds : undefined;
+  };
+
+  return (0, _composerHelpers.compose_)([(0, _composerHelpers.pick_)('visState')((0, _composerHelpers.apply_)(_visStateUpdaters.updateVisDataUpdater, {
+    datasets: datasets,
+    options: options,
+    config: parsedConfig
+  })), (0, _composerHelpers.if_)(Boolean(info), (0, _composerHelpers.pick_)('visState')((0, _composerHelpers.apply_)(_visStateUpdaters.setMapInfoUpdater, {
+    info: info
+  }))), (0, _composerHelpers.with_)(function (_ref2) {
+    var visState = _ref2.visState;
+    return (0, _composerHelpers.pick_)('mapState')((0, _composerHelpers.apply_)(_mapStateUpdaters.receiveMapConfigUpdater, (0, _composerHelpers.payload_)({
+      config: parsedConfig,
+      options: options,
+      bounds: findMapBoundsIfCentered(filterNewlyAddedLayers(visState.layers))
+    })));
+  }), (0, _composerHelpers.pick_)('mapStyle')((0, _composerHelpers.apply_)(_mapStyleUpdaters.receiveMapConfigUpdater, (0, _composerHelpers.payload_)({
+    config: parsedConfig,
+    options: options
+  }))), (0, _composerHelpers.pick_)('uiState')((0, _composerHelpers.apply_)(_uiStateUpdaters.loadFilesSuccessUpdater, (0, _composerHelpers.payload_)(null))), (0, _composerHelpers.pick_)('uiState')((0, _composerHelpers.apply_)(_uiStateUpdaters.toggleModalUpdater, (0, _composerHelpers.payload_)(null))), (0, _composerHelpers.pick_)('uiState')((0, _composerHelpers.merge_)(options.hasOwnProperty('readOnly') ? {
+    readOnly: options.readOnly
+  } : {}))])(state);
+};
+
+exports.addDataToMapUpdater = addDataToMapUpdater;
+
+var loadFilesSuccessUpdater = function loadFilesSuccessUpdater(state, action) {
+  // still more to load
+  var payloads = (0, _processors.filesToDataPayload)(action.result);
+  var nextState = (0, _composerHelpers.compose_)([(0, _composerHelpers.pick_)('visState')((0, _composerHelpers.merge_)({
+    fileLoading: false,
+    fileLoadingProgress: {}
+  }))])(state); // make multiple add data to map calls
+
+  var stateWithData = (0, _composerHelpers.compose_)(payloads.map(function (p) {
+    return (0, _composerHelpers.apply_)(addDataToMapUpdater, (0, _composerHelpers.payload_)(p));
+  }))(nextState);
+  return stateWithData;
+};
+
+exports.loadFilesSuccessUpdater = loadFilesSuccessUpdater;
+var addDataToMapComposed = addDataToMapUpdater;
+exports.addDataToMapComposed = addDataToMapComposed;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/combined-updaters.ts"],"names":["combinedUpdaters","isValidConfig","config","version","defaultAddDataToMapOptions","centerMap","keepExistingConfig","autoCreateLayers","addDataToMapUpdater","state","payload","datasets","info","options","parsedConfig","visState","schema","parseSavedConfig","oldLayers","layers","filterNewlyAddedLayers","filter","nl","find","ol","findMapBoundsIfCentered","bounds","undefined","visStateUpdateVisDataUpdater","Boolean","setMapInfoUpdater","stateMapConfigUpdater","styleMapConfigUpdater","uiStateLoadFilesSuccessUpdater","toggleModalUpdater","hasOwnProperty","readOnly","loadFilesSuccessUpdater","action","payloads","result","nextState","fileLoading","fileLoadingProgress","stateWithData","map","p","addDataToMapComposed"],"mappings":";;;;;;;;;;;AAoBA;;AAIA;;AAIA;;AACA;;AACA;;AACA;;AAOA;;AACA;;;;;;AAUA;;AAEA;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;AACA;AACA;AACA;;AAEA;AACA;AACA,IAAMA,gBAAgB,GAAG,IAAzB;AACA;;AAEO,IAAMC,aAAa,GAAG,SAAhBA,aAAgB,CAAAC,MAAM;AAAA,SACjC,0BAAcA,MAAd,KAAyB,0BAAcA,MAAM,CAACA,MAArB,CAAzB,IAAyDA,MAAM,CAACC,OAD/B;AAAA,CAA5B;;;AAGA,IAAMC,0BAA0B,GAAG;AACxCC,EAAAA,SAAS,EAAE,IAD6B;AAExCC,EAAAA,kBAAkB,EAAE,KAFoB;AAGxCC,EAAAA,gBAAgB,EAAE;AAHsB,CAAnC;AAMP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AACO,IAAMC,mBAAmB,GAAG,SAAtBA,mBAAsB,CACjCC,KADiC,QAGf;AAAA,MADjBC,OACiB,QADjBA,OACiB;AAAA,MACXC,QADW,GACeD,OADf,CACXC,QADW;AAAA,MACDT,MADC,GACeQ,OADf,CACDR,MADC;AAAA,MACOU,IADP,GACeF,OADf,CACOE,IADP;;AAGlB,MAAMC,OAAO,mCACRT,0BADQ,GAERM,OAAO,CAACG,OAFA,CAAb,CAHkB,CAQlB;;;AACA,MAAIC,YAA0B,GAAGZ,MAAjC;;AAEA,MAAID,aAAa,CAACC,MAAD,CAAjB,EAA2B;AACzB;AACA;AACAY,IAAAA,YAAY,GAAGL,KAAK,CAACM,QAAN,CAAeC,MAAf,CAAsBC,gBAAtB,CAAuCf,MAAvC,CAAf;AACD;;AACD,MAAMgB,SAAS,GAAGT,KAAK,CAACM,QAAN,CAAeI,MAAjC;;AACA,MAAMC,sBAAsB,GAAG,SAAzBA,sBAAyB,CAACD,MAAD;AAAA,WAC7BA,MAAM,CAACE,MAAP,CAAc,UAAAC,EAAE;AAAA,aAAI,CAACJ,SAAS,CAACK,IAAV,CAAe,UAAAC,EAAE;AAAA,eAAIA,EAAE,KAAKF,EAAX;AAAA,OAAjB,CAAL;AAAA,KAAhB,CAD6B;AAAA,GAA/B,CAjBkB,CAoBlB;;;AACA,MAAMG,uBAAuB,GAAG,SAA1BA,uBAA0B,CAACN,MAAD,EAAqB;AACnD,QAAMO,MAAM,GAAGb,OAAO,CAACR,SAAR,IAAqB,8BAAcc,MAAd,CAApC;AACA,WAAOO,MAAM,GAAGA,MAAH,GAAYC,SAAzB;AACD,GAHD;;AAKA,SAAO,+BAAwB,CAC7B,4BAAM,UAAN,EACE,6BAAsBC,sCAAtB,EAAoD;AAClDjB,IAAAA,QAAQ,EAARA,QADkD;AAElDE,IAAAA,OAAO,EAAPA,OAFkD;AAGlDX,IAAAA,MAAM,EAAEY;AAH0C,GAApD,CADF,CAD6B,EAS7B,0BACEe,OAAO,CAACjB,IAAD,CADT,EAEE,4BAAM,UAAN,EACE,6BAAsBkB,mCAAtB,EAAyC;AAAClB,IAAAA,IAAI,EAAJA;AAAD,GAAzC,CADF,CAFF,CAT6B,EAgB7B,4BAAM;AAAA,QAAEG,QAAF,SAAEA,QAAF;AAAA,WACJ,4BAAM,UAAN,EACE,6BACEgB,yCADF,EAEE,+BAAS;AACP7B,MAAAA,MAAM,EAAEY,YADD;AAEPD,MAAAA,OAAO,EAAPA,OAFO;AAGPa,MAAAA,MAAM,EAAED,uBAAuB,CAACL,sBAAsB,CAACL,QAAQ,CAACI,MAAV,CAAvB;AAHxB,KAAT,CAFF,CADF,CADI;AAAA,GAAN,CAhB6B,EA4B7B,4BAAM,UAAN,EAAkB,6BAAOa,yCAAP,EAA8B,+BAAS;AAAC9B,IAAAA,MAAM,EAAEY,YAAT;AAAuBD,IAAAA,OAAO,EAAPA;AAAvB,GAAT,CAA9B,CAAlB,CA5B6B,EA6B7B,4BAAM,SAAN,EAAiB,6BAAOoB,wCAAP,EAAuC,+BAAS,IAAT,CAAvC,CAAjB,CA7B6B,EA8B7B,4BAAM,SAAN,EAAiB,6BAAOC,mCAAP,EAA2B,+BAAS,IAAT,CAA3B,CAAjB,CA9B6B,EA+B7B,4BAAM,SAAN,EAAiB,6BAAOrB,OAAO,CAACsB,cAAR,CAAuB,UAAvB,IAAqC;AAACC,IAAAA,QAAQ,EAAEvB,OAAO,CAACuB;AAAnB,GAArC,GAAoE,EAA3E,CAAjB,CA/B6B,CAAxB,EAgCJ3B,KAhCI,CAAP;AAiCD,CA9DM;;;;AAgEA,IAAM4B,uBAAuB,GAAG,SAA1BA,uBAA0B,CACrC5B,KADqC,EAErC6B,MAFqC,EAGnB;AAClB;AACA,MAAMC,QAAQ,GAAG,oCAAmBD,MAAM,CAACE,MAA1B,CAAjB;AACA,MAAMC,SAAS,GAAG,+BAAS,CACzB,4BAAM,UAAN,EACE,6BAAO;AACLC,IAAAA,WAAW,EAAE,KADR;AAELC,IAAAA,mBAAmB,EAAE;AAFhB,GAAP,CADF,CADyB,CAAT,EAOflC,KAPe,CAAlB,CAHkB,CAWlB;;AACA,MAAMmC,aAAa,GAAG,+BAASL,QAAQ,CAACM,GAAT,CAAa,UAAAC,CAAC;AAAA,WAAI,6BAAOtC,mBAAP,EAA4B,+BAASsC,CAAT,CAA5B,CAAJ;AAAA,GAAd,CAAT,EACpBL,SADoB,CAAtB;AAGA,SAAOG,aAAP;AACD,CAnBM;;;AAqBA,IAAMG,oBAAoB,GAAGvC,mBAA7B","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 {\n  toggleModalUpdater,\n  loadFilesSuccessUpdater as uiStateLoadFilesSuccessUpdater\n} from './ui-state-updaters';\nimport {\n  updateVisDataUpdater as visStateUpdateVisDataUpdater,\n  setMapInfoUpdater\n} from './vis-state-updaters';\nimport {receiveMapConfigUpdater as stateMapConfigUpdater} from './map-state-updaters';\nimport {receiveMapConfigUpdater as styleMapConfigUpdater} from './map-style-updaters';\nimport {filesToDataPayload} from '@kepler.gl/processors';\nimport {payload_, apply_, with_, if_, compose_, merge_, pick_} from './composer-helpers';\nimport {MapState, UiState, AddDataToMapPayload, ParsedConfig} from '@kepler.gl/types';\nimport {MapStyle} from './map-style-updaters';\nimport {ProviderState} from './provider-state-updaters';\nimport {loadFilesSuccessUpdaterAction} from '@kepler.gl/actions';\nimport {VisState} from '@kepler.gl/schemas';\nimport {Layer} from '@kepler.gl/layers';\nimport {isPlainObject} from '@kepler.gl/utils';\nimport {findMapBounds} from './data-utils';\n\nexport type KeplerGlState = {\n  visState: VisState;\n  mapState: MapState;\n  mapStyle: MapStyle;\n  uiState: UiState;\n  providerState: ProviderState;\n};\n\n// compose action to apply result multiple reducers, with the output of one\n\n/**\n * Some actions will affect the entire kepler.lg instance state.\n * The updaters for these actions is exported as `combinedUpdaters`. These updater take the entire instance state\n * as the first argument. Read more about [Using updaters](../advanced-usage/using-updaters.md)\n * @public\n * @example\n *\n * import keplerGlReducer, {combinedUpdaters} from 'kepler.gl/reducers';\n * // Root Reducer\n * const reducers = combineReducers({\n *  keplerGl: keplerGlReducer,\n *  app: appReducer\n * });\n *\n * const composedReducer = (state, action) => {\n *  switch (action.type) {\n *    // add data to map after receiving data from remote sources\n *    case 'LOAD_REMOTE_RESOURCE_SUCCESS':\n *      return {\n *        ...state,\n *        keplerGl: {\n *          ...state.keplerGl,\n *          // pass in kepler.gl instance state to combinedUpdaters\n *          map:  combinedUpdaters.addDataToMapUpdater(\n *           state.keplerGl.map,\n *           {\n *             payload: {\n *               datasets: action.datasets,\n *               options: {readOnly: true},\n *               config: action.config\n *              }\n *            }\n *          )\n *        }\n *      };\n *  }\n *  return reducers(state, action);\n * };\n *\n * export default composedReducer;\n */\n\n/* eslint-disable no-unused-vars */\n// @ts-ignore\nconst combinedUpdaters = null;\n/* eslint-enable no-unused-vars */\n\nexport const isValidConfig = config =>\n  isPlainObject(config) && isPlainObject(config.config) && config.version;\n\nexport const defaultAddDataToMapOptions = {\n  centerMap: true,\n  keepExistingConfig: false,\n  autoCreateLayers: true\n};\n\n/**\n * Combine data and full configuration update in a single action\n *\n * @memberof combinedUpdaters\n * @param {Object} state kepler.gl instance state, containing all subreducer state\n * @param {Object} action\n * @param {Object} action.payload `{datasets, options, config}`\n * @param action.payload.datasets - ***required** datasets can be a dataset or an array of datasets\n * Each dataset object needs to have `info` and `data` property.\n * @param [action.payload.options] option object `{centerMap: true}`\n * @param [action.payload.config] map config\n * @param [action.payload.info] map info contains title and description\n * @returns nextState\n *\n * @typedef {Object} Dataset\n * @property info -info of a dataset\n * @property info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.\n * @property info.label - A display name of this dataset\n * @property data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`\n * @property data.fields - ***required** Array of fields,\n * @property data.fields.name - ***required** Name of the field,\n * @property data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`\n *\n * @public\n */\nexport const addDataToMapUpdater = (\n  state: KeplerGlState,\n  {payload}: {payload: AddDataToMapPayload}\n): KeplerGlState => {\n  const {datasets, config, info} = payload;\n\n  const options = {\n    ...defaultAddDataToMapOptions,\n    ...payload.options\n  };\n\n  // @ts-expect-error\n  let parsedConfig: ParsedConfig = config;\n\n  if (isValidConfig(config)) {\n    // if passed in saved config\n    // @ts-expect-error\n    parsedConfig = state.visState.schema.parseSavedConfig(config);\n  }\n  const oldLayers = state.visState.layers;\n  const filterNewlyAddedLayers = (layers: Layer[]) =>\n    layers.filter(nl => !oldLayers.find(ol => ol === nl));\n\n  // Returns undefined if not found, to make typescript happy\n  const findMapBoundsIfCentered = (layers: Layer[]) => {\n    const bounds = options.centerMap && findMapBounds(layers);\n    return bounds ? bounds : undefined;\n  };\n\n  return compose_<KeplerGlState>([\n    pick_('visState')(\n      apply_<VisState, any>(visStateUpdateVisDataUpdater, {\n        datasets,\n        options,\n        config: parsedConfig\n      })\n    ),\n\n    if_(\n      Boolean(info),\n      pick_('visState')(\n        apply_<VisState, any>(setMapInfoUpdater, {info})\n      )\n    ),\n\n    with_(({visState}) =>\n      pick_('mapState')(\n        apply_(\n          stateMapConfigUpdater,\n          payload_({\n            config: parsedConfig,\n            options,\n            bounds: findMapBoundsIfCentered(filterNewlyAddedLayers(visState.layers))\n          })\n        )\n      )\n    ),\n    pick_('mapStyle')(apply_(styleMapConfigUpdater, payload_({config: parsedConfig, options}))),\n    pick_('uiState')(apply_(uiStateLoadFilesSuccessUpdater, payload_(null))),\n    pick_('uiState')(apply_(toggleModalUpdater, payload_(null))),\n    pick_('uiState')(merge_(options.hasOwnProperty('readOnly') ? {readOnly: options.readOnly} : {}))\n  ])(state);\n};\n\nexport const loadFilesSuccessUpdater = (\n  state: KeplerGlState,\n  action: loadFilesSuccessUpdaterAction\n): KeplerGlState => {\n  // still more to load\n  const payloads = filesToDataPayload(action.result);\n  const nextState = compose_([\n    pick_('visState')(\n      merge_({\n        fileLoading: false,\n        fileLoadingProgress: {}\n      })\n    )\n  ])(state);\n  // make multiple add data to map calls\n  const stateWithData = compose_(payloads.map(p => apply_(addDataToMapUpdater, payload_(p))))(\n    nextState\n  );\n  return stateWithData as KeplerGlState;\n};\n\nexport const addDataToMapComposed = addDataToMapUpdater;\n"]}

package/dist/composer-helpers.d.ts

@@ -0,0 +1,21 @@
+/** Returns a function that logs a value with a given message */
+export declare function log(text: string): (value: any) => void;
+/** Wraps a value in an object and stores it the `payload` field */
+export declare function payload_<P>(payload: P): {
+    payload: P;
+};
+/** Wraps a value in an object and stores it the `payload` field */
+export declare function apply_<State, P>(updater: (state: State, nextPayload: P) => State, payload: P): (state: State) => State;
+export declare function with_<State>(fn: (state: State) => (nextState: State) => State): (state: State) => State;
+export declare function if_<State>(pred: boolean, fn: (state: State) => State): (state: State) => State;
+export declare function compose_<State>(fns: Array<(s: State) => State>): (s: State) => State;
+/** Returns a reducer function that merges props with state */
+export declare function merge_<Props>(obj: Props): <State>(state: State) => State;
+export declare function pick_<Prop extends string>(prop: Prop): <Value>(fn: (p: Value) => Value) => <State extends Record<Prop, Value>>(state: State) => State;
+export declare function swap_<X extends {
+    id: string;
+}>(item: X): (arr: X[]) => X[];
+export declare function findById<X extends {
+    id: string;
+}>(id: string): (arr: X[]) => X | undefined;
+export declare function map_<X>(fn: (state: X) => X): (arr: X[]) => X[];

package/dist/composer-helpers.js

@@ -0,0 +1,133 @@
+// 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.log = log;
+exports.payload_ = payload_;
+exports.apply_ = apply_;
+exports.with_ = with_;
+exports.if_ = if_;
+exports.compose_ = compose_;
+exports.merge_ = merge_;
+exports.pick_ = pick_;
+exports.swap_ = swap_;
+exports.findById = findById;
+exports.map_ = map_;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _console = _interopRequireDefault(require("global/console"));
+
+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; }
+
+var identity = function identity(state) {
+  return state;
+};
+/** Returns a function that logs a value with a given message */
+
+
+function log(text) {
+  return function (value) {
+    return _console["default"].log(text, value);
+  };
+}
+/** Wraps a value in an object and stores it the `payload` field */
+
+
+function payload_(payload) {
+  return {
+    payload: payload
+  };
+}
+/** Wraps a value in an object and stores it the `payload` field */
+
+
+function apply_(updater, payload) {
+  return function (state) {
+    return updater(state, payload);
+  };
+}
+
+function with_(fn) {
+  return function (state) {
+    return fn(state)(state);
+  };
+}
+
+function if_(pred, fn) {
+  return pred ? fn : identity;
+}
+
+function compose_(fns) {
+  return function (state) {
+    return fns.reduce(function (state2, fn) {
+      return fn(state2);
+    }, state);
+  };
+}
+/** Returns a reducer function that merges props with state */
+
+
+function merge_(obj) {
+  return function (state) {
+    return _objectSpread(_objectSpread({}, state), obj);
+  };
+}
+
+function pick_(prop) {
+  return function (fn) {
+    return function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, (0, _defineProperty2["default"])({}, prop, fn(state[prop])));
+    };
+  };
+}
+
+function swap_(item) {
+  return function (arr) {
+    return arr.map(function (a) {
+      return a.id === item.id ? item : a;
+    });
+  };
+}
+
+function findById(id) {
+  return function (arr) {
+    return arr.find(function (a) {
+      return a.id === id;
+    });
+  };
+}
+
+function map_(fn) {
+  return function (arr) {
+    return arr.map(function (e) {
+      return fn(e);
+    });
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/composers.d.ts

@@ -0,0 +1,12 @@
+import * as combinedUpdaters from './combined-updaters';
+/**
+ * Important: Do not rename `actionHandler` or the assignment pattern of property value.
+ * It is used to generate documentation
+ */
+declare const actionHandler: {
+    "@@kepler.gl/ADD_DATA_TO_MAP": (state: combinedUpdaters.KeplerGlState, { payload }: {
+        payload: import("@kepler.gl/types").AddDataToMapPayload;
+    }) => combinedUpdaters.KeplerGlState;
+    "@@kepler.gl/LOAD_FILES_SUCCESS": (state: combinedUpdaters.KeplerGlState, action: import("@kepler.gl/actions").loadFilesSuccessUpdaterAction) => combinedUpdaters.KeplerGlState;
+};
+export default actionHandler;

package/dist/composers.js

@@ -0,0 +1,47 @@
+// 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"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _actions = require("@kepler.gl/actions");
+
+var combinedUpdaters = _interopRequireWildcard(require("./combined-updaters"));
+
+var _actionHandler;
+
+/**
+ * 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.ADD_DATA_TO_MAP, combinedUpdaters.addDataToMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.LOAD_FILES_SUCCESS, combinedUpdaters.loadFilesSuccessUpdater), _actionHandler);
+var _default = actionHandler;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/core.d.ts

@@ -0,0 +1,64 @@
+import { VisState } from '@kepler.gl/schemas';
+import { MapState, UiState } from '@kepler.gl/types';
+import { MapStyle } from './map-style-updaters';
+import { ProviderState } from './provider-state-updaters';
+export declare type KeplerGlState = {
+    visState: VisState;
+    mapState: MapState;
+    mapStyle: MapStyle;
+    uiState: UiState;
+    providerState: ProviderState;
+};
+export declare const coreReducerFactory: (initialState?: Partial<KeplerGlState>) => (state: any, action: any) => any;
+declare const _default: (state: any, action: any) => any;
+export default _default;
+/**
+ * Connect subreducer `mapState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export declare const mapStateLens: (reduxState: KeplerGlState) => {
+    mapState: MapState;
+};
+/**
+ * Connect subreducer `mapStyle`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export declare const mapStyleLens: (reduxState: KeplerGlState) => {
+    mapStyle: MapStyle;
+};
+/**
+ * Connect subreducer `visState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export declare const visStateLens: (reduxState: KeplerGlState) => {
+    visState: VisState;
+};
+/**
+ * Connect subreducer `uiState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export declare const uiStateLens: (reduxState: KeplerGlState) => {
+    uiState: UiState;
+};
+/**
+ * Connect subreducer `providerState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export declare const providerStateLens: (reduxState: KeplerGlState) => {
+    providerState: ProviderState;
+};