@kepler.gl/reducers 3.0.0-alpha.0

package/dist/layer-utils.js

@@ -0,0 +1,289 @@
+// 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.findDefaultLayer = findDefaultLayer;
+exports.calculateLayerData = calculateLayerData;
+exports.getLayerHoverProp = getLayerHoverProp;
+exports.renderDeckGlLayer = renderDeckGlLayer;
+exports.isLayerRenderable = isLayerRenderable;
+exports.isLayerVisible = isLayerVisible;
+exports.prepareLayersForDeck = prepareLayersForDeck;
+exports.prepareLayersToRender = prepareLayersToRender;
+exports.getCustomDeckLayers = getCustomDeckLayers;
+exports.computeDeckLayers = computeDeckLayers;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _layers = require("@kepler.gl/layers");
+
+var _utils = require("@kepler.gl/utils");
+
+var _deckglLayers = require("@kepler.gl/deckgl-layers");
+
+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; }
+
+/**
+ * Find default layers from fields
+ */
+function findDefaultLayer(dataset, layerClasses) {
+  if (!dataset) {
+    return [];
+  }
+
+  var layerProps = Object.keys(layerClasses).reduce(function (previous, lc) {
+    var result = typeof layerClasses[lc].findDefaultLayerProps === 'function' ? layerClasses[lc].findDefaultLayerProps(dataset, previous) : {
+      props: []
+    };
+    var props = Array.isArray(result) ? result : result.props || [];
+    var foundLayers = result.foundLayers || previous;
+    return foundLayers.concat(props.map(function (p) {
+      return _objectSpread(_objectSpread({}, p), {}, {
+        type: lc,
+        dataId: dataset.id
+      });
+    }));
+  }, []); // go through all layerProps to create layer
+
+  return layerProps.map(function (props) {
+    // @ts-expect-error TODO: checking props.type !== null
+    var layer = new layerClasses[props.type](props);
+    return typeof layer.setInitialLayerConfig === 'function' && dataset.dataContainer ? layer.setInitialLayerConfig(dataset) : layer;
+  });
+}
+/**
+ * calculate layer data based on layer type, col Config,
+ * return updated layer if colorDomain, dataMap has changed
+ */
+
+
+function calculateLayerData(layer, state, oldLayerData) {
+  var type = layer.type;
+
+  if (!type || !layer.hasAllColumns() || !layer.config.dataId) {
+    return {
+      layer: layer,
+      layerData: {}
+    };
+  }
+
+  var layerData = layer.formatLayerData(state.datasets, oldLayerData);
+  return {
+    layerData: layerData,
+    layer: layer
+  };
+}
+/**
+ * Calculate props passed to LayerHoverInfo
+ * @type {typeof import('./layer-utils').getLayerHoverProp}
+ */
+
+
+function getLayerHoverProp(_ref) {
+  var interactionConfig = _ref.interactionConfig,
+      hoverInfo = _ref.hoverInfo,
+      layers = _ref.layers,
+      layersToRender = _ref.layersToRender,
+      datasets = _ref.datasets;
+
+  if (interactionConfig.tooltip.enabled && hoverInfo && hoverInfo.picked) {
+    // if anything hovered
+    var object = hoverInfo.object,
+        overlay = hoverInfo.layer; // deckgl layer to kepler-gl layer
+
+    var layer = layers[overlay.props.idx];
+
+    if (object && layer && layer.getHoverData && layersToRender[layer.id]) {
+      // if layer is visible and have hovered data
+      var dataId = layer.config.dataId;
+
+      if (!dataId) {
+        return null;
+      }
+
+      var _datasets$dataId = datasets[dataId],
+          dataContainer = _datasets$dataId.dataContainer,
+          fields = _datasets$dataId.fields;
+      var data = layer.getHoverData(object, dataContainer, fields);
+      var fieldsToShow = interactionConfig.tooltip.config.fieldsToShow[dataId];
+      return {
+        data: data,
+        fields: fields,
+        fieldsToShow: fieldsToShow,
+        layer: layer
+      };
+    }
+  }
+
+  return null;
+}
+
+function renderDeckGlLayer(props, layerCallbacks, idx) {
+  var datasets = props.datasets,
+      layers = props.layers,
+      layerData = props.layerData,
+      hoverInfo = props.hoverInfo,
+      clicked = props.clicked,
+      mapState = props.mapState,
+      interactionConfig = props.interactionConfig,
+      animationConfig = props.animationConfig,
+      mapLayers = props.mapLayers;
+  var layer = layers[idx];
+  var data = layerData[idx];
+
+  var _ref2 = datasets[layer.config.dataId] || {},
+      gpuFilter = _ref2.gpuFilter;
+
+  var objectHovered = clicked || hoverInfo;
+  var visible = !mapLayers || mapLayers && mapLayers[layer.id]; // Layer is Layer class
+
+  return layer.renderLayer({
+    data: data,
+    gpuFilter: gpuFilter,
+    idx: idx,
+    interactionConfig: interactionConfig,
+    layerCallbacks: layerCallbacks,
+    mapState: mapState,
+    animationConfig: animationConfig,
+    objectHovered: objectHovered,
+    visible: visible
+  });
+}
+
+function isLayerRenderable(layer, layerData) {
+  return layer.id !== _constants.GEOCODER_LAYER_ID && layer.shouldRenderLayer(layerData);
+}
+
+function isLayerVisible(layer, mapLayers) {
+  return layer.config.isVisible && ( // if layer.id is not in mapLayers, don't render it
+  !mapLayers || mapLayers && mapLayers[layer.id]);
+} // Prepare a dict of layers rendered by the deck.gl
+// Note, isVisible: false layer is passed to deck.gl here
+// return {[id]: true \ false}
+
+
+function prepareLayersForDeck(layers, layerData) {
+  return layers.reduce(function (accu, layer, idx) {
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, layer.id, isLayerRenderable(layer, layerData[idx]) && layer.overlayType === _layers.OVERLAY_TYPE_CONST.deckgl));
+  }, {});
+} // Prepare a dict of rendered layers rendered in the map
+// This includes only the visibile layers for single map view and split map view
+// return {[id]: true \ false}
+
+
+function prepareLayersToRender(layers, layerData, mapLayers) {
+  return layers.reduce(function (accu, layer, idx) {
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, layer.id, isLayerRenderable(layer, layerData[idx]) && isLayerVisible(layer, mapLayers)));
+  }, {});
+}
+
+function getCustomDeckLayers(deckGlProps) {
+  var bottomDeckLayers = Array.isArray(deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.layers) ? deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.layers : (0, _utils.isFunction)(deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.layers) ? deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.layers() : [];
+  var topDeckLayers = Array.isArray(deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.topLayers) ? deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.topLayers : (0, _utils.isFunction)(deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.topLayers) ? deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.topLayers() : [];
+  return [bottomDeckLayers, topDeckLayers];
+}
+
+function computeDeckLayers(_ref3, options, _onSetLayerDomain, deckGlProps) {
+  var visState = _ref3.visState,
+      mapState = _ref3.mapState,
+      mapStyle = _ref3.mapStyle;
+  var datasets = visState.datasets,
+      layers = visState.layers,
+      layerOrder = visState.layerOrder,
+      layerData = visState.layerData,
+      hoverInfo = visState.hoverInfo,
+      clicked = visState.clicked,
+      interactionConfig = visState.interactionConfig,
+      animationConfig = visState.animationConfig,
+      splitMaps = visState.splitMaps;
+
+  var _ref4 = options || {},
+      mapIndex = _ref4.mapIndex,
+      mapboxApiAccessToken = _ref4.mapboxApiAccessToken,
+      mapboxApiUrl = _ref4.mapboxApiUrl,
+      primaryMap = _ref4.primaryMap,
+      layersForDeck = _ref4.layersForDeck;
+
+  var dataLayers = [];
+
+  if (layerData && layerData.length) {
+    var mapLayers = (0, _utils.getMapLayersFromSplitMaps)(splitMaps, mapIndex || 0);
+    var currentLayersForDeck = layersForDeck || prepareLayersForDeck(layers, layerData);
+    dataLayers = layerOrder.slice().reverse().filter(function (idx) {
+      return currentLayersForDeck[layers[idx].id];
+    }).reduce(function (overlays, idx) {
+      var layerCallbacks = _onSetLayerDomain ? {
+        onSetLayerDomain: function onSetLayerDomain(val) {
+          return _onSetLayerDomain(idx, val);
+        }
+      } : {};
+      var layerOverlay = renderDeckGlLayer({
+        datasets: datasets,
+        layers: layers,
+        layerData: layerData,
+        hoverInfo: hoverInfo,
+        clicked: clicked,
+        mapState: mapState,
+        interactionConfig: interactionConfig,
+        animationConfig: animationConfig,
+        mapLayers: mapLayers
+      }, layerCallbacks, idx);
+      return overlays.concat(layerOverlay || []);
+    }, []);
+  }
+
+  if (!primaryMap) {
+    return dataLayers;
+  }
+
+  if (mapStyle !== null && mapStyle !== void 0 && mapStyle.visibleLayerGroups['3d building'] && primaryMap && mapboxApiAccessToken && mapboxApiUrl) {
+    dataLayers.push(new _deckglLayers.ThreeDBuildingLayer({
+      id: '_keplergl_3d-building',
+      mapboxApiAccessToken: mapboxApiAccessToken,
+      mapboxApiUrl: mapboxApiUrl,
+      threeDBuildingColor: mapStyle.threeDBuildingColor,
+      updateTriggers: {
+        getFillColor: mapStyle.threeDBuildingColor
+      }
+    }));
+  }
+
+  var _getCustomDeckLayers = getCustomDeckLayers(deckGlProps),
+      _getCustomDeckLayers2 = (0, _slicedToArray2["default"])(_getCustomDeckLayers, 2),
+      customBottomDeckLayers = _getCustomDeckLayers2[0],
+      customTopDeckLayers = _getCustomDeckLayers2[1];
+
+  return [].concat((0, _toConsumableArray2["default"])(customBottomDeckLayers), (0, _toConsumableArray2["default"])(dataLayers), (0, _toConsumableArray2["default"])(customTopDeckLayers));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/layer-utils.ts"],"names":["findDefaultLayer","dataset","layerClasses","layerProps","Object","keys","reduce","previous","lc","result","findDefaultLayerProps","props","Array","isArray","foundLayers","concat","map","p","type","dataId","id","layer","setInitialLayerConfig","dataContainer","calculateLayerData","state","oldLayerData","hasAllColumns","config","layerData","formatLayerData","datasets","getLayerHoverProp","interactionConfig","hoverInfo","layers","layersToRender","tooltip","enabled","picked","object","overlay","idx","getHoverData","fields","data","fieldsToShow","renderDeckGlLayer","layerCallbacks","clicked","mapState","animationConfig","mapLayers","gpuFilter","objectHovered","visible","renderLayer","isLayerRenderable","GEOCODER_LAYER_ID","shouldRenderLayer","isLayerVisible","isVisible","prepareLayersForDeck","accu","overlayType","OVERLAY_TYPE_CONST","deckgl","prepareLayersToRender","getCustomDeckLayers","deckGlProps","bottomDeckLayers","topDeckLayers","topLayers","computeDeckLayers","options","onSetLayerDomain","visState","mapStyle","layerOrder","splitMaps","mapIndex","mapboxApiAccessToken","mapboxApiUrl","primaryMap","layersForDeck","dataLayers","length","currentLayersForDeck","slice","reverse","filter","overlays","val","layerOverlay","visibleLayerGroups","push","ThreeDBuildingLayer","threeDBuildingColor","updateTriggers","getFillColor","customBottomDeckLayers","customTopDeckLayers"],"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 {GEOCODER_LAYER_ID} from '@kepler.gl/constants';\nimport {\n  Field,\n  TooltipField,\n  CompareType,\n  SplitMapLayers,\n  InteractionConfig\n} from '@kepler.gl/types';\nimport {\n  FindDefaultLayerPropsReturnValue,\n  Layer,\n  LayerClassesType,\n  OVERLAY_TYPE_CONST\n} from '@kepler.gl/layers';\n\nimport KeplerTable, {Datasets} from '@kepler.gl/table';\nimport {VisState} from '@kepler.gl/schemas';\nimport {isFunction, getMapLayersFromSplitMaps, DataRow} from '@kepler.gl/utils';\nimport {ThreeDBuildingLayer} from '@kepler.gl/deckgl-layers';\n\nexport type LayersToRender = {\n  [layerId: string]: boolean;\n};\n\nexport type AggregationLayerHoverData = {points: any[]; colorValue?: any; elevationValue?: any};\n\nexport type LayerHoverProp = {\n  data: DataRow | AggregationLayerHoverData | null;\n  fields: Field[];\n  fieldsToShow: TooltipField[];\n  layer: Layer;\n  primaryData?: DataRow | AggregationLayerHoverData | null;\n  compareType?: CompareType;\n};\n\n/**\n * Find default layers from fields\n */\nexport function findDefaultLayer(dataset: KeplerTable, layerClasses: LayerClassesType): Layer[] {\n  if (!dataset) {\n    return [];\n  }\n  const layerProps = (Object.keys(layerClasses) as Array<keyof LayerClassesType>).reduce(\n    (previous, lc) => {\n      const result: FindDefaultLayerPropsReturnValue =\n        typeof layerClasses[lc].findDefaultLayerProps === 'function'\n          ? layerClasses[lc].findDefaultLayerProps(dataset, previous)\n          : {props: []};\n\n      const props = Array.isArray(result) ? result : result.props || [];\n      const foundLayers = result.foundLayers || previous;\n\n      return foundLayers.concat(\n        props.map(p => ({\n          ...p,\n          type: lc,\n          dataId: dataset.id\n        }))\n      );\n    },\n    [] as LayerClassesType[keyof LayerClassesType][]\n  );\n\n  // go through all layerProps to create layer\n  return layerProps.map(props => {\n    // @ts-expect-error TODO: checking props.type !== null\n    const layer = new layerClasses[props.type](props);\n    return typeof layer.setInitialLayerConfig === 'function' && dataset.dataContainer\n      ? layer.setInitialLayerConfig(dataset)\n      : layer;\n  });\n}\n\n/**\n * calculate layer data based on layer type, col Config,\n * return updated layer if colorDomain, dataMap has changed\n */\nexport function calculateLayerData(\n  layer: Layer,\n  state: {datasets: Datasets},\n  oldLayerData?: any\n): {\n  layerData: any;\n  layer: Layer;\n} {\n  const {type} = layer;\n\n  if (!type || !layer.hasAllColumns() || !layer.config.dataId) {\n    return {layer, layerData: {}};\n  }\n\n  const layerData = layer.formatLayerData(state.datasets, oldLayerData);\n  return {layerData, layer};\n}\n\n/**\n * Calculate props passed to LayerHoverInfo\n * @type {typeof import('./layer-utils').getLayerHoverProp}\n */\nexport function getLayerHoverProp({\n  interactionConfig,\n  hoverInfo,\n  layers,\n  layersToRender,\n  datasets\n}: {\n  interactionConfig: InteractionConfig;\n  hoverInfo: any;\n  layers: Layer[];\n  layersToRender: LayersToRender;\n  datasets: Datasets;\n}): LayerHoverProp | null {\n  if (interactionConfig.tooltip.enabled && hoverInfo && hoverInfo.picked) {\n    // if anything hovered\n    const {object, layer: overlay} = hoverInfo;\n\n    // deckgl layer to kepler-gl layer\n    const layer = layers[overlay.props.idx];\n\n    if (object && layer && layer.getHoverData && layersToRender[layer.id]) {\n      // if layer is visible and have hovered data\n      const {\n        config: {dataId}\n      } = layer;\n      if (!dataId) {\n        return null;\n      }\n      const {dataContainer, fields} = datasets[dataId];\n      const data: DataRow | null = layer.getHoverData(object, dataContainer, fields);\n      const fieldsToShow = interactionConfig.tooltip.config.fieldsToShow[dataId];\n\n      return {\n        data,\n        fields,\n        fieldsToShow,\n        layer\n      };\n    }\n  }\n\n  return null;\n}\n\nexport function renderDeckGlLayer(props: any, layerCallbacks: {[key: string]: any}, idx: number) {\n  const {\n    datasets,\n    layers,\n    layerData,\n    hoverInfo,\n    clicked,\n    mapState,\n    interactionConfig,\n    animationConfig,\n    mapLayers\n  } = props;\n  const layer = layers[idx];\n  const data = layerData[idx];\n  const {gpuFilter} = datasets[layer.config.dataId] || {};\n  const objectHovered = clicked || hoverInfo;\n  const visible = !mapLayers || (mapLayers && mapLayers[layer.id]);\n  // Layer is Layer class\n  return layer.renderLayer({\n    data,\n    gpuFilter,\n    idx,\n    interactionConfig,\n    layerCallbacks,\n    mapState,\n    animationConfig,\n    objectHovered,\n    visible\n  });\n}\n\nexport function isLayerRenderable(layer: Layer, layerData) {\n  return layer.id !== GEOCODER_LAYER_ID && layer.shouldRenderLayer(layerData);\n}\n\nexport function isLayerVisible(layer, mapLayers) {\n  return (\n    layer.config.isVisible &&\n    // if layer.id is not in mapLayers, don't render it\n    (!mapLayers || (mapLayers && mapLayers[layer.id]))\n  );\n}\n\n// Prepare a dict of layers rendered by the deck.gl\n// Note, isVisible: false layer is passed to deck.gl here\n// return {[id]: true \\ false}\nexport function prepareLayersForDeck(\n  layers: Layer[],\n  layerData: any[]\n): {\n  [key: string]: boolean;\n} {\n  return layers.reduce(\n    (accu, layer, idx) => ({\n      ...accu,\n      [layer.id]:\n        isLayerRenderable(layer, layerData[idx]) && layer.overlayType === OVERLAY_TYPE_CONST.deckgl\n    }),\n    {}\n  );\n}\n\n// Prepare a dict of rendered layers rendered in the map\n// This includes only the visibile layers for single map view and split map view\n// return {[id]: true \\ false}\nexport function prepareLayersToRender(\n  layers: Layer[],\n  layerData: VisState['layerData'],\n  mapLayers?: SplitMapLayers | undefined | null\n): LayersToRender {\n  return layers.reduce(\n    (accu, layer, idx) => ({\n      ...accu,\n      [layer.id]: isLayerRenderable(layer, layerData[idx]) && isLayerVisible(layer, mapLayers)\n    }),\n    {}\n  );\n}\n\nexport function getCustomDeckLayers(deckGlProps) {\n  const bottomDeckLayers = Array.isArray(deckGlProps?.layers)\n    ? deckGlProps?.layers\n    : isFunction(deckGlProps?.layers)\n    ? deckGlProps?.layers()\n    : [];\n  const topDeckLayers = Array.isArray(deckGlProps?.topLayers)\n    ? deckGlProps?.topLayers\n    : isFunction(deckGlProps?.topLayers)\n    ? deckGlProps?.topLayers()\n    : [];\n\n  return [bottomDeckLayers, topDeckLayers];\n}\n\nexport type ComputeDeckLayersProps = {\n  mapIndex?: number;\n  mapboxApiAccessToken?: string;\n  mapboxApiUrl?: string;\n  primaryMap?: boolean;\n  layersForDeck?: {[key: string]: boolean};\n};\n\nexport function computeDeckLayers(\n  {visState, mapState, mapStyle}: any,\n  options?: ComputeDeckLayersProps,\n  onSetLayerDomain?: (idx: number, value: any) => void,\n  deckGlProps?: any\n): Layer[] {\n  const {\n    datasets,\n    layers,\n    layerOrder,\n    layerData,\n    hoverInfo,\n    clicked,\n    interactionConfig,\n    animationConfig,\n    splitMaps\n  } = visState;\n\n  const {mapIndex, mapboxApiAccessToken, mapboxApiUrl, primaryMap, layersForDeck} = options || {};\n\n  let dataLayers: any[] = [];\n\n  if (layerData && layerData.length) {\n    const mapLayers = getMapLayersFromSplitMaps(splitMaps, mapIndex || 0);\n\n    const currentLayersForDeck = layersForDeck || prepareLayersForDeck(layers, layerData);\n\n    dataLayers = layerOrder\n      .slice()\n      .reverse()\n      .filter(idx => currentLayersForDeck[layers[idx].id])\n      .reduce((overlays, idx) => {\n        const layerCallbacks = onSetLayerDomain\n          ? {\n              onSetLayerDomain: val => onSetLayerDomain(idx, val)\n            }\n          : {};\n        const layerOverlay = renderDeckGlLayer(\n          {\n            datasets,\n            layers,\n            layerData,\n            hoverInfo,\n            clicked,\n            mapState,\n            interactionConfig,\n            animationConfig,\n            mapLayers\n          },\n          layerCallbacks,\n          idx\n        );\n        return overlays.concat(layerOverlay || []);\n      }, []);\n  }\n\n  if (!primaryMap) {\n    return dataLayers;\n  }\n\n  if (\n    mapStyle?.visibleLayerGroups['3d building'] &&\n    primaryMap &&\n    mapboxApiAccessToken &&\n    mapboxApiUrl\n  ) {\n    dataLayers.push(\n      new ThreeDBuildingLayer({\n        id: '_keplergl_3d-building',\n        mapboxApiAccessToken,\n        mapboxApiUrl,\n        threeDBuildingColor: mapStyle.threeDBuildingColor,\n        updateTriggers: {\n          getFillColor: mapStyle.threeDBuildingColor\n        }\n      })\n    );\n  }\n\n  const [customBottomDeckLayers, customTopDeckLayers] = getCustomDeckLayers(deckGlProps);\n\n  return [...customBottomDeckLayers, ...dataLayers, ...customTopDeckLayers];\n}\n"]}

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

@@ -0,0 +1,62 @@
+import { MapStateActions, ReceiveMapConfigPayload, ActionTypes } from '@kepler.gl/actions';
+import { MapState } from '@kepler.gl/types';
+/**
+ * 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
+ */
+export declare const INITIAL_MAP_STATE: MapState;
+/**
+ * Update map viewport
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export declare const updateMapUpdater: (state: MapState, action: MapStateActions.UpdateMapUpdaterAction) => MapState;
+/**
+ * Fit map viewport to bounds
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export declare const fitBoundsUpdater: (state: MapState, action: MapStateActions.FitBoundsUpdaterAction) => MapState;
+/**
+ * Toggle between 3d and 2d map.
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export declare const togglePerspectiveUpdater: (state: MapState, action: MapStateActions.TogglePerspectiveUpdaterAction) => MapState;
+/**
+ * reset mapState to initial State
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export declare const resetMapConfigUpdater: (state: MapState) => MapState;
+/**
+ * Update `mapState` to propagate a new config
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export declare const receiveMapConfigUpdater: (state: MapState, { payload: { config, options, bounds } }: {
+    type?: typeof ActionTypes.RECEIVE_MAP_CONFIG;
+    payload: ReceiveMapConfigPayload;
+}) => MapState;
+/**
+ * Toggle between one or split maps
+ * @memberof mapStateUpdaters
+ * @public
+ */
+export declare const toggleSplitMapUpdater: (state: MapState, action: MapStateActions.ToggleSplitMapUpdaterAction) => MapState;
+export declare function getMapDimForSplitMap(isSplit: any, state: any): {
+    width?: undefined;
+} | {
+    width: number;
+};