@kepler.gl/reducers 3.0.0-alpha.0

package/dist/core.js

@@ -0,0 +1,149 @@
+// 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.providerStateLens = exports.uiStateLens = exports.visStateLens = exports.mapStyleLens = exports.mapStateLens = exports["default"] = exports.coreReducerFactory = void 0;
+
+var _redux = require("redux");
+
+var _visState = require("./vis-state");
+
+var _mapState = require("./map-state");
+
+var _mapStyle = require("./map-style");
+
+var _uiState = require("./ui-state");
+
+var _providerState = require("./provider-state");
+
+var _composers = _interopRequireDefault(require("./composers"));var combined = function combined() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (0, _redux.combineReducers)({
+    visState: (0, _visState.visStateReducerFactory)(initialState.visState),
+    mapState: (0, _mapState.mapStateReducerFactory)(initialState.mapState),
+    mapStyle: (0, _mapStyle.mapStyleReducerFactory)(initialState.mapStyle),
+    uiState: (0, _uiState.uiStateReducerFactory)(initialState.uiState),
+    providerState: (0, _providerState.providerStateReducerFactory)(initialState.providerState)
+  });
+};
+
+var coreReducerFactory = function coreReducerFactory() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return function (state, action) {
+    if (_composers["default"][action.type]) {
+      return _composers["default"][action.type](state, action);
+    }
+
+    return combined(initialState)(state, action);
+  };
+};
+
+exports.coreReducerFactory = coreReducerFactory;
+
+var _default = coreReducerFactory();
+/**
+ * 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
+ */
+
+
+exports["default"] = _default;
+
+var mapStateLens = function mapStateLens(reduxState) {
+  return {
+    mapState: reduxState.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
+ */
+
+
+exports.mapStateLens = mapStateLens;
+
+var mapStyleLens = function mapStyleLens(reduxState) {
+  return {
+    mapStyle: reduxState.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
+ */
+
+
+exports.mapStyleLens = mapStyleLens;
+
+var visStateLens = function visStateLens(reduxState) {
+  return {
+    visState: reduxState.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
+ */
+
+
+exports.visStateLens = visStateLens;
+
+var uiStateLens = function uiStateLens(reduxState) {
+  return {
+    uiState: reduxState.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
+ */
+
+
+exports.uiStateLens = uiStateLens;
+
+var providerStateLens = function providerStateLens(reduxState) {
+  return {
+    providerState: reduxState.providerState
+  };
+};
+
+exports.providerStateLens = providerStateLens;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/core.ts"],"names":["combined","initialState","visState","mapState","mapStyle","uiState","providerState","coreReducerFactory","state","action","composers","type","mapStateLens","reduxState","mapStyleLens","visStateLens","uiStateLens","providerStateLens"],"mappings":";;;;;;;;;AAoBA;;AAEA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AA5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAyBA,IAAMA,QAAQ,GAAG,SAAXA,QAAW;AAAA,MAACC,YAAD,uEAAwC,EAAxC;AAAA,SACf,4BAAgB;AACdC,IAAAA,QAAQ,EAAE,sCAAuBD,YAAY,CAACC,QAApC,CADI;AAEdC,IAAAA,QAAQ,EAAE,sCAAuBF,YAAY,CAACE,QAApC,CAFI;AAGdC,IAAAA,QAAQ,EAAE,sCAAuBH,YAAY,CAACG,QAApC,CAHI;AAIdC,IAAAA,OAAO,EAAE,oCAAsBJ,YAAY,CAACI,OAAnC,CAJK;AAKdC,IAAAA,aAAa,EAAE,gDAA4BL,YAAY,CAACK,aAAzC;AALD,GAAhB,CADe;AAAA,CAAjB;;AASO,IAAMC,kBAAkB,GAAG,SAArBA,kBAAqB;AAAA,MAACN,YAAD,uEAAwC,EAAxC;AAAA,SAA+C,UAC/EO,KAD+E,EAE/EC,MAF+E,EAG5E;AACH,QAAIC,sBAAUD,MAAM,CAACE,IAAjB,CAAJ,EAA4B;AAC1B,aAAOD,sBAAUD,MAAM,CAACE,IAAjB,EAAuBH,KAAvB,EAA8BC,MAA9B,CAAP;AACD;;AACD,WAAOT,QAAQ,CAACC,YAAD,CAAR,CAAuBO,KAAvB,EAA8BC,MAA9B,CAAP;AACD,GARiC;AAAA,CAA3B;;;;eAUQF,kBAAkB,E;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AACO,IAAMK,YAAY,GAAG,SAAfA,YAAe,CAACC,UAAD;AAAA,SAAgC;AAACV,IAAAA,QAAQ,EAAEU,UAAU,CAACV;AAAtB,GAAhC;AAAA,CAArB;AAEP;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AACO,IAAMW,YAAY,GAAG,SAAfA,YAAe,CAACD,UAAD;AAAA,SAAgC;AAACT,IAAAA,QAAQ,EAAES,UAAU,CAACT;AAAtB,GAAhC;AAAA,CAArB;AAEP;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AACO,IAAMW,YAAY,GAAG,SAAfA,YAAe,CAACF,UAAD;AAAA,SAAgC;AAACX,IAAAA,QAAQ,EAAEW,UAAU,CAACX;AAAtB,GAAhC;AAAA,CAArB;AAEP;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AACO,IAAMc,WAAW,GAAG,SAAdA,WAAc,CAACH,UAAD;AAAA,SAAgC;AAACR,IAAAA,OAAO,EAAEQ,UAAU,CAACR;AAArB,GAAhC;AAAA,CAApB;AAEP;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AACO,IAAMY,iBAAiB,GAAG,SAApBA,iBAAoB,CAACJ,UAAD;AAAA,SAAgC;AAC/DP,IAAAA,aAAa,EAAEO,UAAU,CAACP;AADqC,GAAhC;AAAA,CAA1B","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 {combineReducers} from 'redux';\n\nimport {visStateReducerFactory} from './vis-state';\nimport {mapStateReducerFactory} from './map-state';\nimport {mapStyleReducerFactory} from './map-style';\nimport {uiStateReducerFactory} from './ui-state';\nimport {providerStateReducerFactory} from './provider-state';\n\nimport composers from './composers';\n\nimport {VisState} from '@kepler.gl/schemas';\nimport {MapState, UiState} from '@kepler.gl/types';\nimport {MapStyle} from './map-style-updaters';\nimport {ProviderState} from './provider-state-updaters';\n\nexport type KeplerGlState = {\n  visState: VisState;\n  mapState: MapState;\n  mapStyle: MapStyle;\n  uiState: UiState;\n  providerState: ProviderState;\n};\n\nconst combined = (initialState: Partial<KeplerGlState> = {}) =>\n  combineReducers({\n    visState: visStateReducerFactory(initialState.visState),\n    mapState: mapStateReducerFactory(initialState.mapState),\n    mapStyle: mapStyleReducerFactory(initialState.mapStyle),\n    uiState: uiStateReducerFactory(initialState.uiState),\n    providerState: providerStateReducerFactory(initialState.providerState)\n  });\n\nexport const coreReducerFactory = (initialState: Partial<KeplerGlState> = {}) => (\n  state,\n  action\n) => {\n  if (composers[action.type]) {\n    return composers[action.type](state, action);\n  }\n  return combined(initialState)(state, action);\n};\n\nexport default coreReducerFactory();\n\n/**\n * Connect subreducer `mapState`, used with `injectComponents`. Learn more at\n * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)\n *\n * @param {*} reduxState\n * @public\n */\nexport const mapStateLens = (reduxState: KeplerGlState) => ({mapState: reduxState.mapState});\n\n/**\n * Connect subreducer `mapStyle`, used with `injectComponents`. Learn more at\n * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)\n *\n * @param {*} reduxState\n * @public\n */\nexport const mapStyleLens = (reduxState: KeplerGlState) => ({mapStyle: reduxState.mapStyle});\n\n/**\n * Connect subreducer `visState`, used with `injectComponents`. Learn more at\n * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)\n *\n * @param {*} reduxState\n * @public\n */\nexport const visStateLens = (reduxState: KeplerGlState) => ({visState: reduxState.visState});\n\n/**\n * Connect subreducer `uiState`, used with `injectComponents`. Learn more at\n * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)\n *\n * @param {*} reduxState\n * @public\n */\nexport const uiStateLens = (reduxState: KeplerGlState) => ({uiState: reduxState.uiState});\n\n/**\n * Connect subreducer `providerState`, used with `injectComponents`. Learn more at\n * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)\n *\n * @param {*} reduxState\n * @public\n */\nexport const providerStateLens = (reduxState: KeplerGlState) => ({\n  providerState: reduxState.providerState\n});\n"]}

package/dist/data-utils.d.ts

@@ -0,0 +1,8 @@
+import { Bounds } from '@kepler.gl/types';
+import { Layer } from '@kepler.gl/layers';
+/**
+ * return center of map from given points
+ * @param layers
+ * @returns coordinates of map center, empty if not found
+ */
+export declare function findMapBounds(layers: Layer[]): Bounds | null;

package/dist/data-utils.js

@@ -0,0 +1,60 @@
+// 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";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findMapBounds = findMapBounds;var MAX_LATITUDE = 90;
+var MIN_LATITUDE = -90;
+var MAX_LONGITUDE = 180;
+var MIN_LONGITUDE = -180;
+/**
+ * return center of map from given points
+ * @param layers
+ * @returns coordinates of map center, empty if not found
+ */
+
+function findMapBounds(layers) {
+  // find bounds in formatted layerData
+  // take ALL layers into account when finding map bounds
+  var availableLayerBounds = layers.reduce(function (res, l) {
+    // @ts-expect-error
+    if (l.meta && l.meta.bounds) {
+      // @ts-expect-error
+      res.push(l.meta.bounds);
+    }
+
+    return res;
+  }, []); // return null if no layer is available
+
+  if (availableLayerBounds.length === 0) {
+    return null;
+  } // merge bounds in each layer
+
+
+  var newBounds = availableLayerBounds.reduce(function (res, b) {
+    return [Math.min(res[0], b[0]), Math.min(res[1], b[1]), Math.max(res[2], b[2]), Math.max(res[3], b[3])];
+  }, [MAX_LONGITUDE, MAX_LATITUDE, MIN_LONGITUDE, MIN_LATITUDE]); // @ts-expect-error
+
+  return newBounds;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/export-utils.d.ts

@@ -0,0 +1,21 @@
+import { Field } from '@kepler.gl/types';
+import { Datasets } from '@kepler.gl/table';
+import { DataContainerInterface } from '@kepler.gl/utils';
+interface StateType {
+    visState: {
+        datasets: Datasets;
+    };
+    appName?: string;
+}
+export declare function exportData(state: StateType, options: any): void;
+/**
+ * On export data to csv
+ * @param dataContainer
+ * @param fields `dataset.fields`
+ * @returns csv string
+ */
+export declare function formatCsv(data: DataContainerInterface, fields: Field[]): string;
+declare const exporters: {
+    exportData: typeof exportData;
+};
+export default exporters;

package/dist/export-utils.js

@@ -0,0 +1,124 @@
+// 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";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exportData = exportData;
+exports.formatCsv = formatCsv;
+exports["default"] = void 0;
+
+var _window = require("global/window");
+
+var _d3Dsv = require("d3-dsv");
+
+var _constants = require("@kepler.gl/constants");
+
+var _utils = require("@kepler.gl/utils");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function exportData(state, options) {
+  var visState = state.visState,
+      appName = state.appName;
+  var datasets = visState.datasets;
+  var selectedDataset = options.selectedDataset,
+      dataType = options.dataType,
+      filtered = options.filtered; // get the selected data
+
+  var filename = appName ? appName : _utils.DEFAULT_DATA_NAME;
+  var selectedDatasets = datasets[selectedDataset] ? [datasets[selectedDataset]] : Object.values(datasets);
+
+  if (!selectedDatasets.length) {
+    // error: selected dataset not found.
+    return;
+  }
+
+  selectedDatasets.forEach(function (selectedData) {
+    var _ref = selectedData,
+        dataContainer = _ref.dataContainer,
+        fields = _ref.fields,
+        label = _ref.label,
+        _ref$filteredIdxCPU = _ref.filteredIdxCPU,
+        filteredIdxCPU = _ref$filteredIdxCPU === void 0 ? [] : _ref$filteredIdxCPU;
+    var toExport = filtered ? (0, _utils.createIndexedDataContainer)(dataContainer, filteredIdxCPU) : dataContainer; // start to export data according to selected data type
+
+    switch (dataType) {
+      case _constants.EXPORT_DATA_TYPE.CSV:
+        {
+          var csv = formatCsv(toExport, fields);
+          var fileBlob = new _window.Blob([csv], {
+            type: 'text/csv'
+          });
+          (0, _utils.downloadFile)(fileBlob, "".concat(filename, "_").concat(label, ".csv"));
+          break;
+        }
+      // TODO: support more file types.
+
+      default:
+        break;
+    }
+  });
+}
+/**
+ * On export data to csv
+ * @param dataContainer
+ * @param fields `dataset.fields`
+ * @returns csv string
+ */
+
+
+function formatCsv(data, fields) {
+  var columns = fields.map(function (f) {
+    return f.displayName || f.name;
+  });
+  var formattedData = [columns]; // parse geojson object as string
+
+  var _iterator = _createForOfIteratorHelper(data.rows(true)),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var row = _step.value;
+      formattedData.push(row.map(function (d, i) {
+        return (0, _utils.parseFieldValue)(d, fields[i].type);
+      }));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return (0, _d3Dsv.csvFormatRows)(formattedData);
+}
+
+var exporters = {
+  exportData: exportData
+};
+var _default = exporters;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+export { default } from './root';
+export { default as keplerGlReducer } from './root';
+export { default as keplerGlReducerCore, visStateLens, mapStateLens, uiStateLens, mapStyleLens } from './core';
+export { default as visStateReducer } from './vis-state';
+export { default as mapStateReducer } from './map-state';
+export { default as uiStateReducer } from './ui-state';
+export { default as mapStyleReducer } from './map-style';
+export { default as providerReducer } from './provider-state';
+export * as visStateUpdaters from './vis-state-updaters';
+export * as mapStateUpdaters from './map-state-updaters';
+export * as mapStyleUpdaters from './map-style-updaters';
+export * as uiStateUpdaters from './ui-state-updaters';
+export * as combineUpdaters from './combined-updaters';
+export * as combinedUpdaters from './combined-updaters';
+export type { KeplerGlState } from './combined-updaters';
+export { addDataToMapUpdater } from './combined-updaters';
+export * as visStateMergers from './vis-state-merger';
+export * from './vis-state-selectors';
+export * from './vis-state-merger';
+export * from './provider-state-updaters';
+export * from './provider-state';
+export * from './ui-state';
+export * from './map-state';
+export { getInitialInputStyle, loadMapStylesUpdater, INITIAL_MAP_STYLE } from './map-style-updaters';
+export { INITIAL_MAP_STATE } from './map-state-updaters';
+export * from './composer-helpers';
+export * from './vis-state-updaters';
+export * from './layer-utils';
+export { INITIAL_UI_STATE } from './ui-state-updaters';
+export type { MapboxStyleUrl, MapStyle } from './map-style-updaters';
+export * from './data-utils';
+export * from './export-utils';
+export * from './interaction-utils';
+export * from './layer-utils';
+export * as providerStateUpdaters from './provider-state-updaters';
+export { enhanceReduxMiddleware } from './middleware';