@kepler.gl/reducers 3.0.0-alpha.0

package/dist/vis-state-updaters.js

@@ -0,0 +1,2472 @@
+// 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 _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateStateWithLayerAndData = updateStateWithLayerAndData;
+exports.updateStateOnLayerVisibilityChange = updateStateOnLayerVisibilityChange;
+exports.layerConfigChangeUpdater = layerConfigChangeUpdater;
+exports.layerTextLabelChangeUpdater = layerTextLabelChangeUpdater;
+exports.layerDataIdChangeUpdater = layerDataIdChangeUpdater;
+exports.layerTypeChangeUpdater = layerTypeChangeUpdater;
+exports.layerVisualChannelChangeUpdater = layerVisualChannelChangeUpdater;
+exports.layerVisConfigChangeUpdater = layerVisConfigChangeUpdater;
+exports.setFilterAnimationTimeUpdater = setFilterAnimationTimeUpdater;
+exports.setFilterAnimationWindowUpdater = setFilterAnimationWindowUpdater;
+exports.setFilterUpdater = setFilterUpdater;
+exports.interactionConfigChangeUpdater = interactionConfigChangeUpdater;
+exports.renameDatasetUpdater = renameDatasetUpdater;
+exports.closeSpecificMapAtIndex = closeSpecificMapAtIndex;
+exports.loadFileStepSuccessUpdater = loadFileStepSuccessUpdater;
+exports.loadNextFileUpdater = loadNextFileUpdater;
+exports.makeLoadFileTask = makeLoadFileTask;
+exports.processFileContentUpdater = processFileContentUpdater;
+exports.parseProgress = parseProgress;
+exports.addDefaultLayers = addDefaultLayers;
+exports.addDefaultTooltips = addDefaultTooltips;
+exports.initialFileLoadingProgress = initialFileLoadingProgress;
+exports.updateFileLoadingProgressUpdater = updateFileLoadingProgressUpdater;
+exports.updateAllLayerDomainData = updateAllLayerDomainData;
+exports.updateAnimationDomain = updateAnimationDomain;
+exports.setFeaturesUpdater = setFeaturesUpdater;
+exports.deleteFeatureUpdater = deleteFeatureUpdater;
+exports.setPolygonFilterLayerUpdater = setPolygonFilterLayerUpdater;
+exports.sortTableColumnUpdater = sortTableColumnUpdater;
+exports.pinTableColumnUpdater = pinTableColumnUpdater;
+exports.copyTableColumnUpdater = copyTableColumnUpdater;
+exports.toggleEditorVisibilityUpdater = toggleEditorVisibilityUpdater;
+exports.setFilterAnimationTimeConfigUpdater = setFilterAnimationTimeConfigUpdater;
+exports.setLayerAnimationTimeConfigUpdater = setLayerAnimationTimeConfigUpdater;
+exports.setSelectedFeatureUpdater = exports.setEditorModeUpdater = exports.setMapInfoUpdater = exports.applyCPUFilterUpdater = exports.loadFilesErrUpdater = exports.nextFileBatchUpdater = exports.loadFilesUpdater = exports.updateVisDataUpdater = exports.toggleLayerForMapUpdater = exports.toggleSplitMapUpdater = exports.mouseMoveUpdater = exports.mapClickUpdater = exports.layerClickUpdater = exports.layerHoverUpdater = exports.receiveMapConfigUpdater = exports.resetMapConfigUpdater = exports.updateTableColorUpdater = exports.showDatasetTableUpdater = exports.updateLayerBlendingUpdater = exports.removeDatasetUpdater = exports.reorderLayerUpdater = exports.duplicateLayerUpdater = exports.removeLayerUpdater = exports.addLayerUpdater = exports.removeFilterUpdater = exports.toggleFilterFeatureUpdater = exports.enlargeFilterUpdater = exports.updateLayerAnimationSpeedUpdater = exports.setLayerAnimationTimeUpdater = exports.updateFilterAnimationSpeedUpdater = exports.toggleLayerAnimationControlUpdater = exports.toggleLayerAnimationUpdater = exports.toggleFilterAnimationUpdater = exports.layerColorUIChangeUpdater = exports.addFilterUpdater = exports.setFilterPlotUpdater = exports.INITIAL_VIS_STATE = exports.DEFAULT_EDITOR = exports.DEFAULT_ANIMATION_CONFIG = exports.defaultInteractionConfig = void 0;
+
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _window = require("global/window");
+
+var _tasks = require("react-palm/tasks");
+
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+
+var _lodash2 = _interopRequireDefault(require("lodash.uniq"));
+
+var _lodash3 = _interopRequireDefault(require("lodash.get"));
+
+var _lodash4 = _interopRequireDefault(require("lodash.xor"));
+
+var _copyToClipboard = _interopRequireDefault(require("copy-to-clipboard"));
+
+var _tasks2 = require("@kepler.gl/tasks");
+
+var _actions = require("@kepler.gl/actions");
+
+var _utils = require("@kepler.gl/utils");
+
+var _visStateMerger = require("./vis-state-merger");
+
+var _layers = require("@kepler.gl/layers");
+
+var _constants = require("@kepler.gl/constants");
+
+var _composerHelpers = require("./composer-helpers");
+
+var _schemas = _interopRequireDefault(require("@kepler.gl/schemas"));
+
+var _layerUtils = require("./layer-utils");
+
+var _table = require("@kepler.gl/table");
+
+var _interactionUtils = require("./interaction-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 _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+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; }
+
+// react-palm
+// disable capture exception for react-palm call to withTask
+(0, _tasks.disableStackCapturing)();
+/**
+ * Updaters for `visState` reducer. Can be used in your root reducer to directly modify kepler.gl's state.
+ * Read more about [Using updaters](../advanced-usage/using-updaters.md)
+ *
+ * @public
+ * @example
+ *
+ * import keplerGlReducer, {visStateUpdaters} from 'kepler.gl/reducers';
+ * // Root Reducer
+ * const reducers = combineReducers({
+ *  keplerGl: keplerGlReducer,
+ *  app: appReducer
+ * });
+ *
+ * const composedReducer = (state, action) => {
+ *  switch (action.type) {
+ *    case 'CLICK_BUTTON':
+ *      return {
+ *        ...state,
+ *        keplerGl: {
+ *          ...state.keplerGl,
+ *          foo: {
+ *             ...state.keplerGl.foo,
+ *             visState: visStateUpdaters.enlargeFilterUpdater(
+ *               state.keplerGl.foo.visState,
+ *               {idx: 0}
+ *             )
+ *          }
+ *        }
+ *      };
+ *  }
+ *  return reducers(state, action);
+ * };
+ *
+ * export default composedReducer;
+ */
+
+/* eslint-disable no-unused-vars */
+// @ts-ignore
+
+var visStateUpdaters = null;
+/* eslint-enable no-unused-vars */
+
+var defaultInteractionConfig = {
+  tooltip: {
+    id: 'tooltip',
+    label: 'interactions.tooltip',
+    enabled: true,
+    config: {
+      fieldsToShow: {},
+      compareMode: false,
+      compareType: _constants.COMPARE_TYPES.ABSOLUTE
+    }
+  },
+  geocoder: {
+    id: 'geocoder',
+    label: 'interactions.geocoder',
+    enabled: false,
+    position: null
+  },
+  brush: {
+    id: 'brush',
+    label: 'interactions.brush',
+    enabled: false,
+    config: {
+      // size is in km
+      size: 0.5
+    }
+  },
+  coordinate: {
+    id: 'coordinate',
+    label: 'interactions.coordinate',
+    enabled: false,
+    position: null
+  }
+};
+exports.defaultInteractionConfig = defaultInteractionConfig;
+var DEFAULT_ANIMATION_CONFIG = {
+  domain: null,
+  currentTime: null,
+  speed: 1,
+  isAnimating: false,
+  timeFormat: null,
+  timezone: null,
+  defaultTimeFormat: null
+};
+exports.DEFAULT_ANIMATION_CONFIG = DEFAULT_ANIMATION_CONFIG;
+var DEFAULT_EDITOR = {
+  mode: _constants.EDITOR_MODES.DRAW_POLYGON,
+  features: [],
+  selectedFeature: null,
+  visible: true
+};
+/**
+ * Default initial `visState`
+ * @memberof visStateUpdaters
+ * @constant
+ * @public
+ */
+
+exports.DEFAULT_EDITOR = DEFAULT_EDITOR;
+var INITIAL_VIS_STATE = {
+  // map info
+  mapInfo: {
+    title: '',
+    description: ''
+  },
+  // layers
+  layers: [],
+  layerData: [],
+  layerToBeMerged: [],
+  layerOrder: [],
+  // filters
+  filters: [],
+  filterToBeMerged: [],
+  // a collection of multiple dataset
+  datasets: {},
+  editingDataset: undefined,
+  interactionConfig: defaultInteractionConfig,
+  interactionToBeMerged: undefined,
+  layerBlending: 'normal',
+  hoverInfo: undefined,
+  clicked: undefined,
+  mousePos: {},
+  maxDefaultTooltips: _constants.MAX_DEFAULT_TOOLTIPS,
+  // this is used when user split maps
+  splitMaps: [// this will contain a list of objects to
+    // describe the state of layer availability and visibility for each map
+    // [
+    //   {
+    //      layers: {layer_id: true | false}
+    //   }
+    // ]
+  ],
+  splitMapsToBeMerged: [],
+  // defaults layer classes
+  layerClasses: _layers.LayerClasses,
+  // default animation
+  // time in unix timestamp (milliseconds) (the number of seconds since the Unix Epoch)
+  animationConfig: DEFAULT_ANIMATION_CONFIG,
+  editor: DEFAULT_EDITOR,
+  fileLoading: false,
+  fileLoadingProgress: {},
+  loaders: [],
+  loadOptions: {},
+  // visStateMergers
+  mergers: _visStateMerger.VIS_STATE_MERGERS,
+  // kepler schemas
+  schema: _schemas["default"]
+};
+/**
+ * Update state with updated layer and layerData
+ *
+ */
+
+exports.INITIAL_VIS_STATE = INITIAL_VIS_STATE;
+
+function updateStateWithLayerAndData(state, _ref) {
+  var layerData = _ref.layerData,
+      layer = _ref.layer,
+      idx = _ref.idx;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    layers: state.layers.map(function (lyr, i) {
+      return i === idx ? layer : lyr;
+    }),
+    layerData: layerData ? state.layerData.map(function (d, i) {
+      return i === idx ? layerData : d;
+    }) : state.layerData
+  });
+}
+
+function updateStateOnLayerVisibilityChange(state, layer) {
+  var newState = state;
+
+  if (state.splitMaps.length) {
+    newState = _objectSpread(_objectSpread({}, state), {}, {
+      splitMaps: layer.config.isVisible ? (0, _utils.addNewLayersToSplitMap)(state.splitMaps, layer) : (0, _utils.removeLayerFromSplitMaps)(state.splitMaps, layer)
+    });
+  }
+
+  if (layer.config.animation.enabled) {
+    newState = updateAnimationDomain(state);
+  }
+
+  return newState;
+}
+/**
+ * Update layer base config: dataId, label, column, isVisible
+ * @memberof visStateUpdaters
+ * @returns nextState
+ */
+
+
+function layerConfigChangeUpdater(state, action) {
+  var oldLayer = action.oldLayer;
+  var idx = state.layers.findIndex(function (l) {
+    return l.id === oldLayer.id;
+  });
+  var props = Object.keys(action.newConfig);
+
+  if (typeof action.newConfig.dataId === 'string') {
+    var _action$newConfig = action.newConfig,
+        dataId = _action$newConfig.dataId,
+        restConfig = (0, _objectWithoutProperties2["default"])(_action$newConfig, ["dataId"]);
+    var stateWithDataId = layerDataIdChangeUpdater(state, {
+      oldLayer: oldLayer,
+      newConfig: {
+        dataId: dataId
+      }
+    });
+    var nextLayer = stateWithDataId.layers.find(function (l) {
+      return l.id === oldLayer.id;
+    });
+    return nextLayer && Object.keys(restConfig).length ? layerConfigChangeUpdater(stateWithDataId, {
+      oldLayer: nextLayer,
+      newConfig: restConfig
+    }) : stateWithDataId;
+  }
+
+  var newLayer = oldLayer.updateLayerConfig(action.newConfig);
+  var layerData; // let newLayer;
+
+  if (newLayer.shouldCalculateLayerData(props)) {
+    var oldLayerData = state.layerData[idx];
+    var updateLayerDataResult = (0, _layerUtils.calculateLayerData)(newLayer, state, oldLayerData);
+    layerData = updateLayerDataResult.layerData;
+    newLayer = updateLayerDataResult.layer;
+  }
+
+  var newState = state;
+
+  if ('isVisible' in action.newConfig) {
+    newState = updateStateOnLayerVisibilityChange(state, newLayer);
+  }
+
+  return updateStateWithLayerAndData(newState, {
+    layer: newLayer,
+    layerData: layerData,
+    idx: idx
+  });
+}
+
+function addOrRemoveTextLabels(newFields, textLabel) {
+  var newTextLabel = textLabel.slice();
+  var currentFields = textLabel.map(function (tl) {
+    return tl.field && tl.field.name;
+  }).filter(function (d) {
+    return d;
+  });
+  var addFields = newFields.filter(function (f) {
+    return !currentFields.includes(f.name);
+  });
+  var deleteFields = currentFields.filter(function (f) {
+    return !newFields.find(function (fd) {
+      return fd.name === f;
+    });
+  }); // delete
+
+  newTextLabel = newTextLabel.filter(function (tl) {
+    return tl.field && !deleteFields.includes(tl.field.name);
+  });
+  newTextLabel = !newTextLabel.length ? [_constants.DEFAULT_TEXT_LABEL] : newTextLabel; // add
+
+  newTextLabel = [].concat((0, _toConsumableArray2["default"])(newTextLabel.filter(function (tl) {
+    return tl.field;
+  })), (0, _toConsumableArray2["default"])(addFields.map(function (af) {
+    return _objectSpread(_objectSpread({}, _constants.DEFAULT_TEXT_LABEL), {}, {
+      field: af
+    });
+  })));
+  return newTextLabel;
+}
+
+function updateTextLabelPropAndValue(idx, prop, value, textLabel) {
+  if (!textLabel[idx].hasOwnProperty(prop)) {
+    return textLabel;
+  }
+
+  var newTextLabel = textLabel.slice();
+
+  if (prop && (value || textLabel.length === 1)) {
+    newTextLabel = textLabel.map(function (tl, i) {
+      return i === idx ? _objectSpread(_objectSpread({}, tl), {}, (0, _defineProperty2["default"])({}, prop, value)) : tl;
+    });
+  } else if (prop === 'field' && value === null && textLabel.length > 1) {
+    // remove label when field value is set to null
+    newTextLabel.splice(idx, 1);
+  }
+
+  return newTextLabel;
+}
+/**
+ * Update layer base config: dataId, label, column, isVisible
+ * @memberof visStateUpdaters
+ * @returns nextState
+ */
+
+
+function layerTextLabelChangeUpdater(state, action) {
+  var oldLayer = action.oldLayer,
+      idx = action.idx,
+      prop = action.prop,
+      value = action.value;
+  var textLabel = oldLayer.config.textLabel;
+  var newTextLabel = textLabel.slice();
+
+  if (!textLabel[idx] && idx === textLabel.length) {
+    // if idx is set to length, add empty text label
+    newTextLabel = [].concat((0, _toConsumableArray2["default"])(textLabel), [_constants.DEFAULT_TEXT_LABEL]);
+  }
+
+  if (idx === 'all' && prop === 'fields') {
+    newTextLabel = addOrRemoveTextLabels(value, textLabel);
+  } else {
+    newTextLabel = updateTextLabelPropAndValue(idx, prop, value, newTextLabel);
+  } // update text label prop and value
+
+
+  return layerConfigChangeUpdater(state, {
+    oldLayer: oldLayer,
+    newConfig: {
+      textLabel: newTextLabel
+    }
+  });
+}
+
+function validateExistingLayerWithData(dataset, layerClasses, layer) {
+  var loadedLayer = (0, _visStateMerger.serializeLayer)(layer);
+  return (0, _visStateMerger.validateLayerWithData)(dataset, loadedLayer, layerClasses, {
+    allowEmptyColumn: true
+  });
+}
+/**
+ * Update layer config dataId
+ * @memberof visStateUpdaters
+ * @returns nextState
+ */
+
+
+function layerDataIdChangeUpdater(state, action) {
+  var oldLayer = action.oldLayer,
+      newConfig = action.newConfig;
+  var dataId = newConfig.dataId;
+
+  if (!oldLayer || !state.datasets[dataId]) {
+    return state;
+  }
+
+  var idx = state.layers.findIndex(function (l) {
+    return l.id === oldLayer.id;
+  });
+  var newLayer = oldLayer.updateLayerConfig({
+    dataId: dataId
+  }); // this may happen when a layer is new (type: null and no columns) but it's not ready to be saved
+
+  if (newLayer.isValidToSave()) {
+    var validated = validateExistingLayerWithData(state.datasets[dataId], state.layerClasses, newLayer); // if cant validate it with data create a new one
+
+    if (!validated) {
+      // @ts-expect-error TODO: checking oldLayer.type !== null
+      newLayer = new state.layerClasses[oldLayer.type]({
+        dataId: dataId,
+        id: oldLayer.id
+      });
+    } else {
+      newLayer = validated;
+    }
+  }
+
+  newLayer = newLayer.updateLayerConfig({
+    isVisible: oldLayer.config.isVisible,
+    isConfigActive: true
+  });
+  newLayer.updateLayerDomain(state.datasets);
+
+  var _calculateLayerData = (0, _layerUtils.calculateLayerData)(newLayer, state, undefined),
+      layerData = _calculateLayerData.layerData,
+      layer = _calculateLayerData.layer;
+
+  return updateStateWithLayerAndData(state, {
+    layerData: layerData,
+    layer: layer,
+    idx: idx
+  });
+}
+
+function setInitialLayerConfig(layer, datasets, layerClasses) {
+  var newLayer = layer;
+
+  if (!Object.keys(datasets).length) {
+    // no data is loaded
+    return layer;
+  }
+
+  if (!layer.config.dataId) {
+    // set layer dataId
+    newLayer = layer.updateLayerConfig({
+      dataId: Object.keys(datasets)[0]
+    });
+  }
+
+  var dataset = datasets[newLayer.config.dataId];
+
+  if (!dataset) {
+    return layer;
+  } // find defaut layer props
+
+
+  var result = typeof layerClasses[newLayer.type].findDefaultLayerProps === 'function' ? layerClasses[newLayer.type].findDefaultLayerProps(dataset, []) : {
+    props: []
+  }; // an array of possible props, use 1st one
+
+  var props = Array.isArray(result) ? result : result.props || [];
+
+  if (props.length) {
+    newLayer = new layerClasses[layer.type](_objectSpread(_objectSpread({}, props[0]), {}, {
+      label: newLayer.config.label,
+      dataId: newLayer.config.dataId,
+      isVisible: true,
+      isConfigActive: newLayer.config.isConfigActive
+    }));
+    return typeof newLayer.setInitialLayerConfig === 'function' ? newLayer.setInitialLayerConfig(dataset) : newLayer;
+  }
+
+  return newLayer;
+}
+/**
+ * Update layer type. Previews layer config will be copied if applicable.
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function layerTypeChangeUpdater(state, action) {
+  var oldLayer = action.oldLayer,
+      newType = action.newType;
+
+  if (!oldLayer) {
+    return state;
+  }
+
+  var oldId = oldLayer.id;
+  var idx = state.layers.findIndex(function (l) {
+    return l.id === oldId;
+  });
+
+  if (!state.layerClasses[newType]) {
+    _window.console.error("".concat(newType, " is not a valid layer type"));
+
+    return state;
+  }
+
+  var newLayer = new state.layerClasses[newType]({
+    // keep old layer lable and isConfigActive
+    label: oldLayer.config.label,
+    isConfigActive: oldLayer.config.isConfigActive
+  });
+
+  if (!oldLayer.type) {
+    // if setting layer type on an empty layer
+    newLayer = setInitialLayerConfig(newLayer, state.datasets, state.layerClasses);
+  } else {
+    // get a mint layer, with new id and type
+    // because deck.gl uses id to match between new and old layer.
+    // If type has changed but id is the same, it will break
+    newLayer.assignConfigToLayer(oldLayer.config, oldLayer.visConfigSettings);
+    newLayer.updateLayerDomain(state.datasets);
+  }
+
+  var clicked = state.clicked,
+      hoverInfo = state.hoverInfo;
+
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    clicked: oldLayer.isLayerHovered(clicked) ? undefined : clicked,
+    hoverInfo: oldLayer.isLayerHovered(hoverInfo) ? undefined : hoverInfo
+  });
+
+  var _calculateLayerData2 = (0, _layerUtils.calculateLayerData)(newLayer, newState),
+      layerData = _calculateLayerData2.layerData,
+      layer = _calculateLayerData2.layer;
+
+  newState = updateStateWithLayerAndData(newState, {
+    layerData: layerData,
+    layer: layer,
+    idx: idx
+  });
+
+  if (layer.config.animation.enabled || oldLayer.config.animation.enabled) {
+    newState = updateAnimationDomain(newState);
+  } // update splitMap layer id
+
+
+  if (state.splitMaps.length) {
+    newState = _objectSpread(_objectSpread({}, newState), {}, {
+      splitMaps: newState.splitMaps.map(function (settings) {
+        var _settings$layers = settings.layers,
+            oldLayerMap = _settings$layers[oldId],
+            otherLayers = (0, _objectWithoutProperties2["default"])(_settings$layers, [oldId].map(_toPropertyKey));
+        return oldId in settings.layers ? _objectSpread(_objectSpread({}, settings), {}, {
+          layers: _objectSpread(_objectSpread({}, otherLayers), {}, (0, _defineProperty2["default"])({}, layer.id, oldLayerMap))
+        }) : settings;
+      })
+    });
+  }
+
+  return newState;
+}
+/**
+ * Update layer visual channel
+ * @memberof visStateUpdaters
+ * @returns {Object} nextState
+ * @public
+ */
+
+
+function layerVisualChannelChangeUpdater(state, action) {
+  var oldLayer = action.oldLayer,
+      newConfig = action.newConfig,
+      channel = action.channel;
+
+  if (!oldLayer.config.dataId) {
+    return state;
+  }
+
+  var dataset = state.datasets[oldLayer.config.dataId];
+  var idx = state.layers.findIndex(function (l) {
+    return l.id === oldLayer.id;
+  });
+  var newLayer = oldLayer.updateLayerConfig(newConfig);
+  newLayer.updateLayerVisualChannel(dataset, channel);
+  var oldLayerData = state.layerData[idx];
+
+  var _calculateLayerData3 = (0, _layerUtils.calculateLayerData)(newLayer, state, oldLayerData),
+      layerData = _calculateLayerData3.layerData,
+      layer = _calculateLayerData3.layer;
+
+  return updateStateWithLayerAndData(state, {
+    layerData: layerData,
+    layer: layer,
+    idx: idx
+  });
+}
+/**
+ * Update layer `visConfig`
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function layerVisConfigChangeUpdater(state, action) {
+  var oldLayer = action.oldLayer;
+  var idx = state.layers.findIndex(function (l) {
+    return l.id === oldLayer.id;
+  });
+  var props = Object.keys(action.newVisConfig);
+
+  var newVisConfig = _objectSpread(_objectSpread({}, oldLayer.config.visConfig), action.newVisConfig);
+
+  var newLayer = oldLayer.updateLayerConfig({
+    visConfig: newVisConfig
+  });
+
+  if (newLayer.shouldCalculateLayerData(props)) {
+    var oldLayerData = state.layerData[idx];
+
+    var _calculateLayerData4 = (0, _layerUtils.calculateLayerData)(newLayer, state, oldLayerData),
+        layerData = _calculateLayerData4.layerData,
+        layer = _calculateLayerData4.layer;
+
+    return updateStateWithLayerAndData(state, {
+      layerData: layerData,
+      layer: layer,
+      idx: idx
+    });
+  }
+
+  return updateStateWithLayerAndData(state, {
+    layer: newLayer,
+    idx: idx
+  });
+}
+/**
+ * Update filter property
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function setFilterAnimationTimeUpdater(state, action) {
+  return setFilterUpdater(state, action);
+}
+/**
+ * Update filter animation window
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function setFilterAnimationWindowUpdater(state, _ref2) {
+  var id = _ref2.id,
+      animationWindow = _ref2.animationWindow;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    filters: state.filters.map(function (f) {
+      return f.id === id ? _objectSpread(_objectSpread({}, f), {}, {
+        animationWindow: animationWindow
+      }) : f;
+    })
+  });
+}
+/**
+ * Update filter property
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function setFilterUpdater(state, action) {
+  var idx = action.idx,
+      prop = action.prop,
+      value = action.value,
+      _action$valueIndex = action.valueIndex,
+      valueIndex = _action$valueIndex === void 0 ? 0 : _action$valueIndex;
+  var oldFilter = state.filters[idx];
+
+  if (!oldFilter) {
+    _window.console.error("filters.".concat(idx, " is undefined"));
+
+    return state;
+  }
+
+  var newFilter = (0, _utils.set)([prop], value, oldFilter);
+  var newState = state;
+  var _newFilter = newFilter,
+      dataId = _newFilter.dataId; // Ensuring backward compatibility
+
+  var datasetIds = (0, _utils.toArray)(dataId);
+
+  switch (prop) {
+    // TODO: Next PR for UI if we update dataId, we need to consider two cases:
+    // 1. dataId is empty: create a default filter
+    // 2. Add a new dataset id
+    case _utils.FILTER_UPDATER_PROPS.dataId:
+      // if trying to update filter dataId. create an empty new filter
+      newFilter = (0, _utils.updateFilterDataId)(dataId);
+      break;
+
+    case _utils.FILTER_UPDATER_PROPS.name:
+      // we are supporting the current functionality
+      // TODO: Next PR for UI filter name will only update filter name but it won't have side effects
+      // we are gonna use pair of datasets and fieldIdx to update the filter
+      var datasetId = newFilter.dataId[valueIndex];
+
+      var _applyFilterFieldName = (0, _utils.applyFilterFieldName)(newFilter, state.datasets[datasetId], value, valueIndex, {
+        mergeDomain: false
+      }),
+          updatedFilter = _applyFilterFieldName.filter,
+          newDataset = _applyFilterFieldName.dataset;
+
+      if (!updatedFilter) {
+        return state;
+      }
+
+      newFilter = updatedFilter;
+
+      if (newFilter.gpu) {
+        newFilter = (0, _table.setFilterGpuMode)(newFilter, state.filters);
+        newFilter = (0, _table.assignGpuChannel)(newFilter, state.filters);
+      }
+
+      newState = (0, _utils.set)(['datasets', datasetId], newDataset, state); // only filter the current dataset
+
+      break;
+
+    case _utils.FILTER_UPDATER_PROPS.layerId:
+      // We need to update only datasetId/s if we have added/removed layers
+      // - check for layerId changes (XOR works because of string values)
+      // if no differences between layerIds, don't do any filtering
+      // @ts-ignore
+      var layerIdDifference = (0, _lodash4["default"])(newFilter.layerId, oldFilter.layerId);
+      var layerDataIds = (0, _lodash2["default"])(layerIdDifference.map(function (lid) {
+        return (0, _lodash3["default"])(state.layers.find(function (l) {
+          return l.id === lid;
+        }), ['config', 'dataId']);
+      }).filter(function (d) {
+        return d;
+      })); // only filter datasetsIds
+
+      datasetIds = layerDataIds; // Update newFilter dataIds
+
+      var newDataIds = (0, _lodash2["default"])(newFilter.layerId.map(function (lid) {
+        return (0, _lodash3["default"])(state.layers.find(function (l) {
+          return l.id === lid;
+        }), ['config', 'dataId']);
+      }).filter(function (d) {
+        return d;
+      }));
+      newFilter = _objectSpread(_objectSpread({}, newFilter), {}, {
+        dataId: newDataIds
+      });
+      break;
+
+    default:
+      break;
+  }
+
+  var enlargedFilter = state.filters.find(function (f) {
+    return f.enlarged;
+  });
+
+  if (enlargedFilter && enlargedFilter.id !== newFilter.id) {
+    // there should be only one enlarged filter
+    newFilter.enlarged = false;
+  } // save new filters to newState
+
+
+  newState = (0, _utils.set)(['filters', idx], newFilter, newState); // if we are currently setting a prop that only requires to filter the current
+  // dataset we will pass only the current dataset to applyFiltersToDatasets and
+  // updateAllLayerDomainData otherwise we pass the all list of datasets as defined in dataId
+
+  var datasetIdsToFilter = _utils.LIMITED_FILTER_EFFECT_PROPS[prop] ? [datasetIds[valueIndex]] : datasetIds; // filter data
+
+  var filteredDatasets = (0, _utils.applyFiltersToDatasets)(datasetIdsToFilter, newState.datasets, newState.filters, newState.layers);
+  newState = (0, _utils.set)(['datasets'], filteredDatasets, newState); // dataId is an array
+  // pass only the dataset we need to update
+
+  newState = updateAllLayerDomainData(newState, datasetIdsToFilter, newFilter);
+  return newState;
+}
+/**
+ * Set the property of a filter plot
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+var setFilterPlotUpdater = function setFilterPlotUpdater(state, _ref3) {
+  var idx = _ref3.idx,
+      newProp = _ref3.newProp,
+      _ref3$valueIndex = _ref3.valueIndex,
+      valueIndex = _ref3$valueIndex === void 0 ? 0 : _ref3$valueIndex;
+
+  var newFilter = _objectSpread(_objectSpread({}, state.filters[idx]), newProp);
+
+  var prop = Object.keys(newProp)[0];
+
+  if (prop === 'yAxis') {
+    var plotType = (0, _utils.getDefaultFilterPlotType)(newFilter); // TODO: plot is not supported in multi dataset filter for now
+
+    if (plotType) {
+      newFilter = _objectSpread(_objectSpread(_objectSpread({}, newFilter), (0, _utils.getFilterPlot)(_objectSpread(_objectSpread({}, newFilter), {}, {
+        plotType: plotType
+      }), state.datasets[newFilter.dataId[valueIndex]])), {}, {
+        plotType: plotType
+      });
+    }
+  }
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    filters: state.filters.map(function (f, i) {
+      return i === idx ? newFilter : f;
+    })
+  });
+};
+/**
+ * Add a new filter
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.setFilterPlotUpdater = setFilterPlotUpdater;
+
+var addFilterUpdater = function addFilterUpdater(state, action) {
+  return !action.dataId ? state : _objectSpread(_objectSpread({}, state), {}, {
+    filters: [].concat((0, _toConsumableArray2["default"])(state.filters), [(0, _utils.getDefaultFilter)(action.dataId)])
+  });
+};
+/**
+ * Set layer color palette ui state
+ * @memberof visStateUpdaters
+ */
+
+
+exports.addFilterUpdater = addFilterUpdater;
+
+var layerColorUIChangeUpdater = function layerColorUIChangeUpdater(state, _ref4) {
+  var oldLayer = _ref4.oldLayer,
+      prop = _ref4.prop,
+      newConfig = _ref4.newConfig;
+  var oldVixConfig = oldLayer.config.visConfig[prop];
+  var newLayer = oldLayer.updateLayerColorUI(prop, newConfig);
+  var newVisConfig = newLayer.config.visConfig[prop];
+
+  if (oldVixConfig !== newVisConfig) {
+    return layerVisConfigChangeUpdater(state, {
+      oldLayer: oldLayer,
+      newVisConfig: (0, _defineProperty2["default"])({}, prop, newVisConfig)
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    layers: state.layers.map(function (l) {
+      return l.id === oldLayer.id ? newLayer : l;
+    })
+  });
+};
+/**
+ * Start and end filter animation
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.layerColorUIChangeUpdater = layerColorUIChangeUpdater;
+
+var toggleFilterAnimationUpdater = function toggleFilterAnimationUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    filters: state.filters.map(function (f, i) {
+      return i === action.idx ? _objectSpread(_objectSpread({}, f), {}, {
+        isAnimating: !f.isAnimating
+      }) : f;
+    })
+  });
+};
+/**
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.toggleFilterAnimationUpdater = toggleFilterAnimationUpdater;
+
+var toggleLayerAnimationUpdater = function toggleLayerAnimationUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    animationConfig: _objectSpread(_objectSpread({}, state.animationConfig), {}, {
+      isAnimating: !state.animationConfig.isAnimating
+    })
+  });
+};
+/**
+ * Hide and show layer animation control
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.toggleLayerAnimationUpdater = toggleLayerAnimationUpdater;
+
+var toggleLayerAnimationControlUpdater = function toggleLayerAnimationControlUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    animationConfig: _objectSpread(_objectSpread({}, state.animationConfig), {}, {
+      hideControl: !state.animationConfig.hideControl
+    })
+  });
+};
+/**
+ * Change filter animation speed
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.toggleLayerAnimationControlUpdater = toggleLayerAnimationControlUpdater;
+
+var updateFilterAnimationSpeedUpdater = function updateFilterAnimationSpeedUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    filters: state.filters.map(function (f, i) {
+      return i === action.idx ? _objectSpread(_objectSpread({}, f), {}, {
+        speed: action.speed
+      }) : f;
+    })
+  });
+};
+/**
+ * Reset animation config current time to a specified value
+ * @memberof visStateUpdaters
+ * @public
+ *
+ */
+
+
+exports.updateFilterAnimationSpeedUpdater = updateFilterAnimationSpeedUpdater;
+
+var setLayerAnimationTimeUpdater = function setLayerAnimationTimeUpdater(state, _ref5) {
+  var value = _ref5.value;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    animationConfig: _objectSpread(_objectSpread({}, state.animationConfig), {}, {
+      currentTime: value
+    })
+  });
+};
+/**
+ * Update animation speed with the vertical speed slider
+ * @memberof visStateUpdaters
+ * @public
+ *
+ */
+
+
+exports.setLayerAnimationTimeUpdater = setLayerAnimationTimeUpdater;
+
+var updateLayerAnimationSpeedUpdater = function updateLayerAnimationSpeedUpdater(state, _ref6) {
+  var speed = _ref6.speed;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    animationConfig: _objectSpread(_objectSpread({}, state.animationConfig), {}, {
+      speed: speed
+    })
+  });
+};
+/**
+ * Show larger time filter at bottom for time playback (apply to time filter only)
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.updateLayerAnimationSpeedUpdater = updateLayerAnimationSpeedUpdater;
+
+var enlargeFilterUpdater = function enlargeFilterUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    filters: state.filters.map(function (f, i) {
+      return i === action.idx ? _objectSpread(_objectSpread({}, f), {}, {
+        enlarged: !f.enlarged
+      }) : f;
+    })
+  });
+};
+/**
+ * Toggles filter feature visibility
+ * @memberof visStateUpdaters
+ */
+
+
+exports.enlargeFilterUpdater = enlargeFilterUpdater;
+
+var toggleFilterFeatureUpdater = function toggleFilterFeatureUpdater(state, action) {
+  var filter = state.filters[action.idx];
+  var isVisible = (0, _lodash3["default"])(filter, ['value', 'properties', 'isVisible']);
+
+  var newFilter = _objectSpread(_objectSpread({}, filter), {}, {
+    value: (0, _utils.featureToFilterValue)(filter.value, filter.id, {
+      isVisible: !isVisible
+    })
+  });
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    filters: Object.assign((0, _toConsumableArray2["default"])(state.filters), (0, _defineProperty2["default"])({}, action.idx, newFilter))
+  });
+};
+/**
+ * Remove a filter
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.toggleFilterFeatureUpdater = toggleFilterFeatureUpdater;
+
+var removeFilterUpdater = function removeFilterUpdater(state, action) {
+  var idx = action.idx;
+  var _state$filters$idx = state.filters[idx],
+      dataId = _state$filters$idx.dataId,
+      id = _state$filters$idx.id;
+  var newFilters = [].concat((0, _toConsumableArray2["default"])(state.filters.slice(0, idx)), (0, _toConsumableArray2["default"])(state.filters.slice(idx + 1, state.filters.length)));
+  var filteredDatasets = (0, _utils.applyFiltersToDatasets)(dataId, state.datasets, newFilters, state.layers);
+  var newEditor = (0, _utils.getFilterIdInFeature)(state.editor.selectedFeature) === id ? _objectSpread(_objectSpread({}, state.editor), {}, {
+    selectedFeature: null
+  }) : state.editor;
+  var newState = (0, _utils.set)(['filters'], newFilters, state);
+  newState = (0, _utils.set)(['datasets'], filteredDatasets, newState);
+  newState = (0, _utils.set)(['editor'], newEditor, newState);
+  return updateAllLayerDomainData(newState, dataId, undefined);
+};
+/**
+ * Add a new layer
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.removeFilterUpdater = removeFilterUpdater;
+
+var addLayerUpdater = function addLayerUpdater(state, action) {
+  var newLayer;
+  var newLayerData;
+
+  if (action.config) {
+    newLayer = (0, _visStateMerger.createLayerFromConfig)(state, action.config);
+
+    if (!newLayer) {
+      _window.console.warn('Failed to create layer from config, it usually means the config is not be in correct format', action.config);
+
+      return state;
+    }
+
+    var result = (0, _layerUtils.calculateLayerData)(newLayer, state);
+    newLayer = result.layer;
+    newLayerData = result.layerData;
+  } else {
+    var _action$datasetId;
+
+    // create an empty layer with a specific dataset or a default one
+    var defaultDataset = (_action$datasetId = action.datasetId) !== null && _action$datasetId !== void 0 ? _action$datasetId : Object.keys(state.datasets)[0];
+    newLayer = new _layers.Layer({
+      isVisible: true,
+      isConfigActive: true,
+      dataId: defaultDataset
+    });
+    newLayerData = {};
+  }
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    layers: [].concat((0, _toConsumableArray2["default"])(state.layers), [newLayer]),
+    layerData: [].concat((0, _toConsumableArray2["default"])(state.layerData), [newLayerData]),
+    layerOrder: [].concat((0, _toConsumableArray2["default"])(state.layerOrder), [state.layerOrder.length]),
+    splitMaps: (0, _utils.addNewLayersToSplitMap)(state.splitMaps, newLayer)
+  });
+};
+/**
+ * remove layer
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.addLayerUpdater = addLayerUpdater;
+
+var removeLayerUpdater = function removeLayerUpdater(state, _ref7) {
+  var idx = _ref7.idx;
+  var layers = state.layers,
+      layerData = state.layerData,
+      clicked = state.clicked,
+      hoverInfo = state.hoverInfo;
+  var layerToRemove = state.layers[idx];
+  var newMaps = (0, _utils.removeLayerFromSplitMaps)(state.splitMaps, layerToRemove);
+
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    layers: [].concat((0, _toConsumableArray2["default"])(layers.slice(0, idx)), (0, _toConsumableArray2["default"])(layers.slice(idx + 1, layers.length))),
+    layerData: [].concat((0, _toConsumableArray2["default"])(layerData.slice(0, idx)), (0, _toConsumableArray2["default"])(layerData.slice(idx + 1, layerData.length))),
+    layerOrder: state.layerOrder.filter(function (i) {
+      return i !== idx;
+    }).map(function (pid) {
+      return pid > idx ? pid - 1 : pid;
+    }),
+    clicked: layerToRemove.isLayerHovered(clicked) ? undefined : clicked,
+    hoverInfo: layerToRemove.isLayerHovered(hoverInfo) ? undefined : hoverInfo,
+    splitMaps: newMaps // TODO: update filters, create helper to remove layer form filter (remove layerid and dataid) if mapped
+
+  });
+
+  return updateAnimationDomain(newState);
+};
+/**
+ * duplicate layer
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.removeLayerUpdater = removeLayerUpdater;
+
+var duplicateLayerUpdater = function duplicateLayerUpdater(state, _ref8) {
+  var idx = _ref8.idx;
+  var layers = state.layers;
+  var original = state.layers[idx];
+  var originalLayerOrderIdx = state.layerOrder.findIndex(function (i) {
+    return i === idx;
+  });
+
+  if (!original) {
+    _window.console.warn("layer.".concat(idx, " is undefined"));
+
+    return state;
+  }
+
+  var newLabel = "Copy of ".concat(original.config.label);
+  var postfix = 0; // eslint-disable-next-line no-loop-func
+
+  while (layers.find(function (l) {
+    return l.config.label === newLabel;
+  })) {
+    newLabel = "Copy of ".concat(original.config.label, " ").concat(++postfix);
+  } // collect layer config from original
+
+
+  var loadedLayer = (0, _visStateMerger.serializeLayer)(original); // assign new id and label to copied layer
+
+  if (!(loadedLayer !== null && loadedLayer !== void 0 && loadedLayer.config)) {
+    return state;
+  }
+
+  loadedLayer.config.label = newLabel;
+  loadedLayer.id = (0, _utils.generateHashId)(_layers.LAYER_ID_LENGTH); // add layer to state
+
+  var nextState = addLayerUpdater(state, {
+    config: loadedLayer
+  }); // new added layer are at the end, move it to be on top of original layer
+
+  var newLayerOrderIdx = nextState.layerOrder.length - 1;
+  var newLayerOrder = (0, _utils.arrayInsert)(nextState.layerOrder.slice(0, newLayerOrderIdx), originalLayerOrderIdx, newLayerOrderIdx);
+  nextState = _objectSpread(_objectSpread({}, nextState), {}, {
+    layerOrder: newLayerOrder
+  });
+  return updateAnimationDomain(nextState);
+};
+/**
+ * Reorder layer
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.duplicateLayerUpdater = duplicateLayerUpdater;
+
+var reorderLayerUpdater = function reorderLayerUpdater(state, _ref9) {
+  var order = _ref9.order;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    layerOrder: order
+  });
+};
+/**
+ * Remove a dataset and all layers, filters, tooltip configs that based on it
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.reorderLayerUpdater = reorderLayerUpdater;
+
+var removeDatasetUpdater = function removeDatasetUpdater(state, action) {
+  // extract dataset key
+  var datasetKey = action.dataId;
+  var datasets = state.datasets; // check if dataset is present
+
+  if (!datasets[datasetKey]) {
+    return state;
+  }
+  /* eslint-disable no-unused-vars */
+
+
+  var layers = state.layers,
+      _state$datasets = state.datasets,
+      dataset = _state$datasets[datasetKey],
+      newDatasets = (0, _objectWithoutProperties2["default"])(_state$datasets, [datasetKey].map(_toPropertyKey));
+  /* eslint-enable no-unused-vars */
+
+  var indexes = layers.reduce(function (listOfIndexes, layer, index) {
+    if (layer.config.dataId === datasetKey) {
+      // @ts-ignore
+      listOfIndexes.push(index);
+    }
+
+    return listOfIndexes;
+  }, []); // remove layers and datasets
+
+  var _indexes$reduce = indexes.reduce(function (_ref10, idx) {
+    var currentState = _ref10.newState,
+        indexCounter = _ref10.indexCounter;
+    var currentIndex = idx - indexCounter;
+    currentState = removeLayerUpdater(currentState, {
+      idx: currentIndex
+    });
+    indexCounter++;
+    return {
+      newState: currentState,
+      indexCounter: indexCounter
+    };
+  }, {
+    newState: _objectSpread(_objectSpread({}, state), {}, {
+      datasets: newDatasets
+    }),
+    indexCounter: 0
+  }),
+      newState = _indexes$reduce.newState; // remove filters
+
+
+  var filters = state.filters.filter(function (filter) {
+    return !filter.dataId.includes(datasetKey);
+  }); // update interactionConfig
+
+  var interactionConfig = state.interactionConfig;
+  var _interactionConfig = interactionConfig,
+      tooltip = _interactionConfig.tooltip;
+
+  if (tooltip) {
+    var config = tooltip.config;
+    /* eslint-disable no-unused-vars */
+
+    var _config$fieldsToShow = config.fieldsToShow,
+        fields = _config$fieldsToShow[datasetKey],
+        fieldsToShow = (0, _objectWithoutProperties2["default"])(_config$fieldsToShow, [datasetKey].map(_toPropertyKey));
+    /* eslint-enable no-unused-vars */
+
+    interactionConfig = _objectSpread(_objectSpread({}, interactionConfig), {}, {
+      tooltip: _objectSpread(_objectSpread({}, tooltip), {}, {
+        config: _objectSpread(_objectSpread({}, config), {}, {
+          fieldsToShow: fieldsToShow
+        })
+      })
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, newState), {}, {
+    filters: filters,
+    interactionConfig: interactionConfig
+  });
+};
+/**
+ * update layer blending mode
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.removeDatasetUpdater = removeDatasetUpdater;
+
+var updateLayerBlendingUpdater = function updateLayerBlendingUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    layerBlending: action.mode
+  });
+};
+/**
+ * Display dataset table in a modal
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.updateLayerBlendingUpdater = updateLayerBlendingUpdater;
+
+var showDatasetTableUpdater = function showDatasetTableUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    editingDataset: action.dataId
+  });
+};
+/**
+ * Add custom color for datasets and layers
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.showDatasetTableUpdater = showDatasetTableUpdater;
+
+var updateTableColorUpdater = function updateTableColorUpdater(state, action) {
+  var dataId = action.dataId,
+      newColor = action.newColor;
+  var datasets = state.datasets;
+
+  if ((0, _utils.isRgbColor)(newColor)) {
+    var existing = datasets[dataId];
+    existing.updateTableColor(newColor);
+    return _objectSpread(_objectSpread({}, state), {}, {
+      datasets: _objectSpread(_objectSpread({}, state.datasets), {}, (0, _defineProperty2["default"])({}, dataId, (0, _table.copyTableAndUpdate)(existing, {})))
+    });
+  }
+
+  return state;
+};
+/**
+ * reset visState to initial State
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.updateTableColorUpdater = updateTableColorUpdater;
+
+var resetMapConfigUpdater = function resetMapConfigUpdater(state) {
+  return _objectSpread(_objectSpread(_objectSpread({}, INITIAL_VIS_STATE), state.initialState), {}, {
+    initialState: state.initialState
+  });
+};
+/**
+ * Propagate `visState` reducer with a new configuration. Current config will be override.
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.resetMapConfigUpdater = resetMapConfigUpdater;
+
+var receiveMapConfigUpdater = function receiveMapConfigUpdater(state, _ref11) {
+  var _ref11$payload = _ref11.payload,
+      _ref11$payload$config = _ref11$payload.config,
+      config = _ref11$payload$config === void 0 ? {
+    version: ''
+  } : _ref11$payload$config,
+      _ref11$payload$option = _ref11$payload.options,
+      options = _ref11$payload$option === void 0 ? {} : _ref11$payload$option;
+
+  if (!config.visState) {
+    return state;
+  }
+
+  var keepExistingConfig = options.keepExistingConfig; // reset config if keepExistingConfig is falsy
+
+  var mergedState = !keepExistingConfig ? resetMapConfigUpdater(state) : state;
+
+  var _iterator = _createForOfIteratorHelper(state.mergers),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var merger = _step.value;
+
+      if ((0, _visStateMerger.isValidMerger)(merger) && config.visState[merger.prop]) {
+        mergedState = merger.merge(mergedState, config.visState[merger.prop], true);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return mergedState;
+};
+/**
+ * Trigger layer hover event with hovered object
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.receiveMapConfigUpdater = receiveMapConfigUpdater;
+
+var layerHoverUpdater = function layerHoverUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    hoverInfo: _objectSpread({}, action.info)
+  });
+};
+/* eslint-enable max-statements */
+
+/**
+ * Update `interactionConfig`
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.layerHoverUpdater = layerHoverUpdater;
+
+function interactionConfigChangeUpdater(state, action) {
+  var config = action.config;
+
+  var interactionConfig = _objectSpread(_objectSpread({}, state.interactionConfig), (0, _defineProperty2["default"])({}, config.id, config)); // Don't enable tooltip and brush at the same time
+  // but coordinates can be shown at all time
+
+
+  var contradict = ['brush', 'tooltip'];
+
+  if (contradict.includes(config.id) && config.enabled && !state.interactionConfig[config.id].enabled) {
+    // only enable one interaction at a time
+    contradict.forEach(function (k) {
+      if (k !== config.id) {
+        interactionConfig[k] = _objectSpread(_objectSpread({}, interactionConfig[k]), {}, {
+          enabled: false
+        });
+      }
+    });
+  }
+
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    interactionConfig: interactionConfig
+  });
+
+  if (config.id === 'geocoder' && !config.enabled) {
+    return removeDatasetUpdater(newState, {
+      dataId: 'geocoder_dataset'
+    });
+  }
+
+  return newState;
+}
+/**
+ * Trigger layer click event with clicked object
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+var layerClickUpdater = function layerClickUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    mousePos: state.interactionConfig.coordinate.enabled ? _objectSpread(_objectSpread({}, state.mousePos), {}, {
+      pinned: state.mousePos.pinned ? null : (0, _lodash["default"])(state.mousePos)
+    }) : state.mousePos,
+    clicked: action.info && action.info.picked ? action.info : null
+  });
+};
+/**
+ * Trigger map click event, unselect clicked object
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.layerClickUpdater = layerClickUpdater;
+
+var mapClickUpdater = function mapClickUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    clicked: null
+  });
+};
+/**
+ * Trigger map move event
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.mapClickUpdater = mapClickUpdater;
+
+var mouseMoveUpdater = function mouseMoveUpdater(state, _ref12) {
+  var evt = _ref12.evt;
+
+  if (Object.values(state.interactionConfig).some(function (config) {
+    return config.enabled;
+  })) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      mousePos: _objectSpread(_objectSpread(_objectSpread({}, state.mousePos), Array.isArray(evt.point) ? {
+        mousePosition: (0, _toConsumableArray2["default"])(evt.point)
+      } : {}), Array.isArray(evt.lngLat) ? {
+        coordinate: (0, _toConsumableArray2["default"])(evt.lngLat)
+      } : {})
+    });
+  }
+
+  return state;
+};
+/**
+ * Toggle visibility of a layer for a split map
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.mouseMoveUpdater = mouseMoveUpdater;
+
+var toggleSplitMapUpdater = function toggleSplitMapUpdater(state, action) {
+  return state.splitMaps && state.splitMaps.length === 0 ? _objectSpread(_objectSpread({}, state), {}, {
+    // maybe we should use an array to store state for a single map as well
+    // if current maps length is equal to 0 it means that we are about to split the view
+    splitMaps: (0, _utils.computeSplitMapLayers)(state.layers)
+  }) : closeSpecificMapAtIndex(state, action);
+};
+/**
+ * Toggle visibility of a layer in a split map
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.toggleSplitMapUpdater = toggleSplitMapUpdater;
+
+var toggleLayerForMapUpdater = function toggleLayerForMapUpdater(state, _ref13) {
+  var mapIndex = _ref13.mapIndex,
+      layerId = _ref13.layerId;
+  var splitMaps = state.splitMaps;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    splitMaps: splitMaps.map(function (sm, i) {
+      return i === mapIndex ? _objectSpread(_objectSpread({}, splitMaps[i]), {}, {
+        layers: _objectSpread(_objectSpread({}, splitMaps[i].layers), {}, (0, _defineProperty2["default"])({}, layerId, !splitMaps[i].layers[layerId]))
+      }) : sm;
+    })
+  });
+};
+/**
+ * Add new dataset to `visState`, with option to load a map config along with the datasets
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+/* eslint-disable max-statements */
+// eslint-disable-next-line complexity
+
+
+exports.toggleLayerForMapUpdater = toggleLayerForMapUpdater;
+
+var updateVisDataUpdater = function updateVisDataUpdater(state, action) {
+  // datasets can be a single data entries or an array of multiple data entries
+  var config = action.config,
+      options = action.options;
+  var datasets = (0, _utils.toArray)(action.datasets);
+  var newDataEntries = datasets.reduce(function (accu) {
+    var _ref14 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        _ref14$info = _ref14.info,
+        info = _ref14$info === void 0 ? {} : _ref14$info,
+        rest = (0, _objectWithoutProperties2["default"])(_ref14, ["info"]);
+
+    return _objectSpread(_objectSpread({}, accu), (0, _table.createNewDataEntry)(_objectSpread({
+      info: info
+    }, rest), state.datasets) || {});
+  }, {});
+  var dataEmpty = Object.keys(newDataEntries).length < 1; // apply config if passed from action
+
+  var previousState = config ? receiveMapConfigUpdater(state, {
+    payload: {
+      config: config,
+      options: options
+    }
+  }) : state;
+
+  var mergedState = _objectSpread(_objectSpread({}, previousState), {}, {
+    datasets: _objectSpread(_objectSpread({}, previousState.datasets), newDataEntries)
+  }); // merge state with config to be merged
+
+
+  var _iterator2 = _createForOfIteratorHelper(mergedState.mergers),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var merger = _step2.value;
+
+      if ((0, _visStateMerger.isValidMerger)(merger) && merger.toMergeProp && mergedState[merger.toMergeProp]) {
+        var toMerge = mergedState[merger.toMergeProp];
+        mergedState[merger.toMergeProp] = INITIAL_VIS_STATE[merger.toMergeProp];
+        mergedState = merger.merge(mergedState, toMerge);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  var newLayers = !dataEmpty ? mergedState.layers.filter(function (l) {
+    return l.config.dataId && l.config.dataId in newDataEntries;
+  }) : [];
+
+  if (!newLayers.length && (options || {}).autoCreateLayers !== false) {
+    // no layer merged, find defaults
+    var result = addDefaultLayers(mergedState, newDataEntries);
+    mergedState = result.state;
+    newLayers = result.newLayers;
+  }
+
+  if (mergedState.splitMaps.length) {
+    // if map is split, add new layers to splitMaps
+    newLayers = mergedState.layers.filter(function (l) {
+      return l.config.dataId && l.config.dataId in newDataEntries;
+    });
+    mergedState = _objectSpread(_objectSpread({}, mergedState), {}, {
+      splitMaps: (0, _utils.addNewLayersToSplitMap)(mergedState.splitMaps, newLayers)
+    });
+  } // if no tooltips merged add default tooltips
+
+
+  Object.keys(newDataEntries).forEach(function (dataId) {
+    var tooltipFields = mergedState.interactionConfig.tooltip.config.fieldsToShow[dataId];
+
+    if (!Array.isArray(tooltipFields) || !tooltipFields.length) {
+      mergedState = addDefaultTooltips(mergedState, newDataEntries[dataId]);
+    }
+  });
+  var updatedState = updateAllLayerDomainData(mergedState, dataEmpty ? Object.keys(mergedState.datasets) : Object.keys(newDataEntries), undefined); // register layer animation domain,
+  // need to be called after layer data is calculated
+
+  updatedState = updateAnimationDomain(updatedState);
+  return updatedState;
+};
+/* eslint-enable max-statements */
+
+/**
+ * Rename an existing dataset in `visState`
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.updateVisDataUpdater = updateVisDataUpdater;
+
+function renameDatasetUpdater(state, action) {
+  var dataId = action.dataId,
+      label = action.label;
+  var datasets = state.datasets;
+  var existing = datasets[dataId];
+
+  if (existing) {
+    var newDataset = (0, _table.copyTableAndUpdate)(existing, {
+      label: label
+    });
+    return _objectSpread(_objectSpread({}, state), {}, {
+      datasets: _objectSpread(_objectSpread({}, datasets), {}, (0, _defineProperty2["default"])({}, dataId, newDataset))
+    });
+  } // No-op if the dataset doesn't exist
+
+
+  return state;
+}
+/**
+ * When a user clicks on the specific map closing icon
+ * the application will close the selected map
+ * and will merge the remaining one with the global state
+ * TODO: i think in the future this action should be called merge map layers with global settings
+ * @param {Object} state `visState`
+ * @param {Object} action action
+ * @returns {Object} nextState
+ */
+
+
+function closeSpecificMapAtIndex(state, action) {
+  var _state$splitMaps$inde;
+
+  // retrieve layers meta data from the remaining map that we need to keep
+  var indexToRetrieve = 1 - action.payload;
+  var mapLayers = (_state$splitMaps$inde = state.splitMaps[indexToRetrieve]) === null || _state$splitMaps$inde === void 0 ? void 0 : _state$splitMaps$inde.layers;
+  var layers = state.layers; // update layer visibility
+
+  var newLayers = layers.map(function (layer) {
+    return mapLayers && !mapLayers[layer.id] && layer.config.isVisible ? layer.updateLayerConfig({
+      // if layer.id is not in mapLayers, it should be inVisible
+      isVisible: false
+    }) : layer;
+  }); // delete map
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    layers: newLayers,
+    splitMaps: []
+  });
+}
+/**
+ * Trigger file loading dispatch `addDataToMap` if succeed, or `loadFilesErr` if failed
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+var loadFilesUpdater = function loadFilesUpdater(state, action) {
+  var files = action.files,
+      _action$onFinish = action.onFinish,
+      onFinish = _action$onFinish === void 0 ? _actions.loadFilesSuccess : _action$onFinish;
+
+  if (!files.length) {
+    return state;
+  }
+
+  var fileLoadingProgress = Array.from(files).reduce(function (accu, f, i) {
+    return (0, _composerHelpers.merge_)(initialFileLoadingProgress(f, i))(accu);
+  }, {});
+  var fileLoading = {
+    fileCache: [],
+    filesToLoad: files,
+    onFinish: onFinish
+  };
+  var nextState = (0, _composerHelpers.merge_)({
+    fileLoadingProgress: fileLoadingProgress,
+    fileLoading: fileLoading
+  })(state);
+  return loadNextFileUpdater(nextState);
+};
+/**
+ * Sucessfully loaded one file, move on to the next one
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.loadFilesUpdater = loadFilesUpdater;
+
+function loadFileStepSuccessUpdater(state, action) {
+  if (!state.fileLoading) {
+    return state;
+  }
+
+  var fileName = action.fileName,
+      fileCache = action.fileCache;
+  var _state$fileLoading = state.fileLoading,
+      filesToLoad = _state$fileLoading.filesToLoad,
+      onFinish = _state$fileLoading.onFinish;
+  var stateWithProgress = updateFileLoadingProgressUpdater(state, {
+    fileName: fileName,
+    progress: {
+      percent: 1,
+      message: 'Done'
+    }
+  }); // save processed file to fileCache
+
+  var stateWithCache = (0, _composerHelpers.pick_)('fileLoading')((0, _composerHelpers.merge_)({
+    fileCache: fileCache
+  }))(stateWithProgress);
+  return (0, _tasks.withTask)(stateWithCache, (0, _tasks2.DELAY_TASK)(200).map(filesToLoad.length ? _actions.loadNextFile : function () {
+    return onFinish(fileCache);
+  }));
+} // withTask<T>(state: T, task: any): T
+
+/**
+ *
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function loadNextFileUpdater(state) {
+  if (!state.fileLoading) {
+    return state;
+  }
+
+  var filesToLoad = state.fileLoading.filesToLoad;
+
+  var _filesToLoad = (0, _toArray2["default"])(filesToLoad),
+      file = _filesToLoad[0],
+      remainingFilesToLoad = _filesToLoad.slice(1); // save filesToLoad to state
+
+
+  var nextState = (0, _composerHelpers.pick_)('fileLoading')((0, _composerHelpers.merge_)({
+    filesToLoad: remainingFilesToLoad
+  }))(state);
+  var stateWithProgress = updateFileLoadingProgressUpdater(nextState, {
+    fileName: file.name,
+    progress: {
+      percent: 0,
+      message: 'loading...'
+    }
+  });
+  var loaders = state.loaders,
+      loadOptions = state.loadOptions;
+  return (0, _tasks.withTask)(stateWithProgress, makeLoadFileTask(file, nextState.fileLoading && nextState.fileLoading.fileCache, loaders, loadOptions));
+}
+
+function makeLoadFileTask(file, fileCache) {
+  var loaders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var loadOptions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  return (0, _tasks2.LOAD_FILE_TASK)({
+    file: file,
+    fileCache: fileCache,
+    loaders: loaders,
+    loadOptions: loadOptions
+  }).bimap( // prettier ignore
+  // success
+  function (gen) {
+    return (0, _actions.nextFileBatch)({
+      gen: gen,
+      fileName: file.name,
+      onFinish: function onFinish(result) {
+        return (0, _actions.processFileContent)({
+          content: result,
+          fileCache: fileCache
+        });
+      }
+    });
+  }, // error
+  function (err) {
+    return (0, _actions.loadFilesErr)(file.name, err);
+  });
+}
+/**
+ *
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function processFileContentUpdater(state, action) {
+  var _action$payload = action.payload,
+      content = _action$payload.content,
+      fileCache = _action$payload.fileCache;
+  var stateWithProgress = updateFileLoadingProgressUpdater(state, {
+    fileName: content.fileName,
+    progress: {
+      percent: 1,
+      message: 'processing...'
+    }
+  });
+  return (0, _tasks.withTask)(stateWithProgress, (0, _tasks2.PROCESS_FILE_DATA)({
+    content: content,
+    fileCache: fileCache
+  }).bimap(function (result) {
+    return (0, _actions.loadFileStepSuccess)({
+      fileName: content.fileName,
+      fileCache: result
+    });
+  }, function (err) {
+    return (0, _actions.loadFilesErr)(content.fileName, err);
+  }));
+}
+
+function parseProgress() {
+  var prevProgress = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var progress = arguments.length > 1 ? arguments[1] : undefined;
+
+  // This happens when receiving query metadata or other cases we don't
+  // have an update for the user.
+  if (!progress || !progress.percent) {
+    return {};
+  }
+
+  return {
+    percent: progress.percent
+  };
+}
+/**
+ * gets called with payload = AsyncGenerator<???>
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+var nextFileBatchUpdater = function nextFileBatchUpdater(state, _ref15) {
+  var _ref15$payload = _ref15.payload,
+      gen = _ref15$payload.gen,
+      fileName = _ref15$payload.fileName,
+      progress = _ref15$payload.progress,
+      accumulated = _ref15$payload.accumulated,
+      onFinish = _ref15$payload.onFinish;
+  var stateWithProgress = updateFileLoadingProgressUpdater(state, {
+    fileName: fileName,
+    progress: parseProgress(state.fileLoadingProgress[fileName], progress)
+  });
+  return (0, _tasks.withTask)(stateWithProgress, (0, _tasks2.UNWRAP_TASK)(gen.next()).bimap(function (_ref16) {
+    var value = _ref16.value,
+        done = _ref16.done;
+    return done ? onFinish(accumulated) : (0, _actions.nextFileBatch)({
+      gen: gen,
+      fileName: fileName,
+      progress: value.progress,
+      accumulated: value,
+      onFinish: onFinish
+    });
+  }, function (err) {
+    return (0, _actions.loadFilesErr)(fileName, err);
+  }));
+};
+/**
+ * Trigger loading file error
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.nextFileBatchUpdater = nextFileBatchUpdater;
+
+var loadFilesErrUpdater = function loadFilesErrUpdater(state, _ref17) {
+  var error = _ref17.error,
+      fileName = _ref17.fileName;
+
+  // update ui with error message
+  _window.console.warn(error);
+
+  if (!state.fileLoading) {
+    return state;
+  }
+
+  var _state$fileLoading2 = state.fileLoading,
+      filesToLoad = _state$fileLoading2.filesToLoad,
+      onFinish = _state$fileLoading2.onFinish,
+      fileCache = _state$fileLoading2.fileCache;
+  var nextState = updateFileLoadingProgressUpdater(state, {
+    fileName: fileName,
+    progress: {
+      error: error
+    }
+  }); // kick off next file or finish
+
+  return (0, _tasks.withTask)(nextState, (0, _tasks2.DELAY_TASK)(200).map(filesToLoad.length ? _actions.loadNextFile : function () {
+    return onFinish(fileCache);
+  }));
+};
+/**
+ * When select dataset for export, apply cpu filter to selected dataset
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.loadFilesErrUpdater = loadFilesErrUpdater;
+
+var applyCPUFilterUpdater = function applyCPUFilterUpdater(state, _ref18) {
+  var dataId = _ref18.dataId;
+  // apply cpuFilter
+  var dataIds = (0, _utils.toArray)(dataId);
+  return dataIds.reduce(function (accu, id) {
+    return (0, _utils.filterDatasetCPU)(accu, id);
+  }, state);
+};
+/**
+ * User input to update the info of the map
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+exports.applyCPUFilterUpdater = applyCPUFilterUpdater;
+
+var setMapInfoUpdater = function setMapInfoUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    mapInfo: _objectSpread(_objectSpread({}, state.mapInfo), action.info)
+  });
+};
+/**
+ * Helper function to update All layer domain and layer data of state
+ */
+
+
+exports.setMapInfoUpdater = setMapInfoUpdater;
+
+function addDefaultLayers(state, datasets) {
+  var empty = [];
+  var defaultLayers = Object.values(datasets).reduce(function (accu, dataset) {
+    var foundLayers = (0, _layerUtils.findDefaultLayer)(dataset, state.layerClasses);
+    return foundLayers && foundLayers.length ? accu.concat(foundLayers) : accu;
+  }, empty);
+  return {
+    state: _objectSpread(_objectSpread({}, state), {}, {
+      layers: [].concat((0, _toConsumableArray2["default"])(state.layers), (0, _toConsumableArray2["default"])(defaultLayers)),
+      layerOrder: [].concat((0, _toConsumableArray2["default"])(defaultLayers.map(function (_, i) {
+        return state.layers.length + i;
+      })), (0, _toConsumableArray2["default"])(state.layerOrder))
+    }),
+    newLayers: defaultLayers
+  };
+}
+/**
+ * helper function to find default tooltips
+ * @param {Object} state
+ * @param {Object} dataset
+ * @returns {Object} nextState
+ */
+
+
+function addDefaultTooltips(state, dataset) {
+  var tooltipFields = (0, _interactionUtils.findFieldsToShow)(_objectSpread(_objectSpread({}, dataset), {}, {
+    maxDefaultTooltips: state.maxDefaultTooltips
+  }));
+
+  var merged = _objectSpread(_objectSpread({}, state.interactionConfig.tooltip.config.fieldsToShow), tooltipFields);
+
+  return (0, _utils.set)(['interactionConfig', 'tooltip', 'config', 'fieldsToShow'], merged, state);
+}
+
+function initialFileLoadingProgress(file, index) {
+  var fileName = file.name || "Untitled File ".concat(index);
+  return (0, _defineProperty2["default"])({}, fileName, {
+    // percent of current file
+    percent: 0,
+    message: '',
+    fileName: fileName,
+    error: null
+  });
+}
+
+function updateFileLoadingProgressUpdater(state, _ref20) {
+  var fileName = _ref20.fileName,
+      progress = _ref20.progress;
+  // @ts-expect-error
+  return (0, _composerHelpers.pick_)('fileLoadingProgress')((0, _composerHelpers.pick_)(fileName)((0, _composerHelpers.merge_)(progress)))(state);
+}
+/**
+ * Helper function to update layer domains for an array of datasets
+ */
+
+
+function updateAllLayerDomainData(state, dataId, updatedFilter) {
+  var dataIds = typeof dataId === 'string' ? [dataId] : dataId;
+  var newLayers = [];
+  var newLayerData = [];
+  state.layers.forEach(function (oldLayer, i) {
+    if (oldLayer.config.dataId && dataIds.includes(oldLayer.config.dataId)) {
+      // No need to recalculate layer domain if filter has fixed domain
+      var newLayer = updatedFilter && updatedFilter.fixedDomain ? oldLayer : oldLayer.updateLayerDomain(state.datasets, updatedFilter);
+
+      var _calculateLayerData5 = (0, _layerUtils.calculateLayerData)(newLayer, state, state.layerData[i]),
+          layerData = _calculateLayerData5.layerData,
+          layer = _calculateLayerData5.layer;
+
+      newLayers.push(layer);
+      newLayerData.push(layerData);
+    } else {
+      newLayers.push(oldLayer);
+      newLayerData.push(state.layerData[i]);
+    }
+  });
+
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    layers: newLayers,
+    layerData: newLayerData
+  });
+
+  return newState;
+}
+
+function updateAnimationDomain(state) {
+  // merge all animatable layer domain and update global config
+  var animatableLayers = state.layers.filter(function (l) {
+    return l.config.isVisible && l.config.animation && l.config.animation.enabled && // @ts-expect-error trip-layer-only
+    Array.isArray(l.animationDomain);
+  });
+
+  if (!animatableLayers.length) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      animationConfig: _objectSpread(_objectSpread({}, state.animationConfig), {}, {
+        domain: null,
+        defaultTimeFormat: null
+      })
+    });
+  }
+
+  var mergedDomain = animatableLayers.reduce(function (accu, layer) {
+    return [// @ts-expect-error trip-layer-only
+    Math.min(accu[0], layer.animationDomain[0]), // @ts-expect-error trip-layer-only
+    Math.max(accu[1], layer.animationDomain[1])];
+  }, [Number(Infinity), -Infinity]);
+  var defaultTimeFormat = (0, _utils.getTimeWidgetTitleFormatter)(mergedDomain);
+  return _objectSpread(_objectSpread({}, state), {}, {
+    animationConfig: _objectSpread(_objectSpread({}, state.animationConfig), {}, {
+      currentTime: (0, _utils.isInRange)(state.animationConfig.currentTime, mergedDomain) ? state.animationConfig.currentTime : mergedDomain[0],
+      domain: mergedDomain,
+      defaultTimeFormat: defaultTimeFormat
+    })
+  });
+}
+/**
+ * Update the status of the editor
+ * @memberof visStateUpdaters
+ */
+
+
+var setEditorModeUpdater = function setEditorModeUpdater(state, _ref21) {
+  var mode = _ref21.mode;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    editor: _objectSpread(_objectSpread({}, state.editor), {}, {
+      mode: mode,
+      selectedFeature: null
+    })
+  });
+}; // const featureToFilterValue = (feature) => ({...feature, id: feature.id});
+
+/**
+ * Update editor features
+ * @memberof visStateUpdaters
+ */
+
+
+exports.setEditorModeUpdater = setEditorModeUpdater;
+
+function setFeaturesUpdater(state, _ref22) {
+  var _ref22$features = _ref22.features,
+      features = _ref22$features === void 0 ? [] : _ref22$features;
+  var lastFeature = features.length && features[features.length - 1];
+
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    editor: _objectSpread(_objectSpread({}, state.editor), {}, {
+      // only save none filter features to editor
+      features: features.filter(function (f) {
+        return !(0, _utils.getFilterIdInFeature)(f);
+      }),
+      mode: lastFeature && lastFeature.properties.isClosed ? _constants.EDITOR_MODES.EDIT : state.editor.mode
+    })
+  }); // Retrieve existing feature
+
+
+  var selectedFeature = state.editor.selectedFeature; // If no feature is selected we can simply return since no operations
+
+  if (!selectedFeature) {
+    return newState;
+  } // TODO: check if the feature has changed
+
+
+  var feature = features.find(function (f) {
+    return f.id === selectedFeature.id;
+  }); // if feature is part of a filter
+
+  var filterId = feature && (0, _utils.getFilterIdInFeature)(feature);
+
+  if (filterId && feature) {
+    var featureValue = (0, _utils.featureToFilterValue)(feature, filterId);
+    var filterIdx = state.filters.findIndex(function (fil) {
+      return fil.id === filterId;
+    }); // @ts-ignore
+
+    return setFilterUpdater(newState, {
+      idx: filterIdx,
+      prop: 'value',
+      value: featureValue
+    });
+  }
+
+  return newState;
+}
+/**
+ * Set the current selected feature
+ * @memberof uiStateUpdaters
+ */
+
+
+var setSelectedFeatureUpdater = function setSelectedFeatureUpdater(state, _ref23) {
+  var feature = _ref23.feature;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    editor: _objectSpread(_objectSpread({}, state.editor), {}, {
+      selectedFeature: feature
+    })
+  });
+};
+/**
+ * Delete existing feature from filters
+ * @memberof visStateUpdaters
+ */
+
+
+exports.setSelectedFeatureUpdater = setSelectedFeatureUpdater;
+
+function deleteFeatureUpdater(state, _ref24) {
+  var feature = _ref24.feature;
+
+  if (!feature) {
+    return state;
+  }
+
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    editor: _objectSpread(_objectSpread({}, state.editor), {}, {
+      selectedFeature: null
+    })
+  });
+
+  if ((0, _utils.getFilterIdInFeature)(feature)) {
+    var filterIdx = newState.filters.findIndex(function (f) {
+      return f.id === (0, _utils.getFilterIdInFeature)(feature);
+    });
+    return filterIdx > -1 ? removeFilterUpdater(newState, {
+      idx: filterIdx
+    }) : newState;
+  } // modify editor object
+
+
+  var newEditor = _objectSpread(_objectSpread({}, state.editor), {}, {
+    features: state.editor.features.filter(function (f) {
+      return f.id !== feature.id;
+    }),
+    selectedFeature: null
+  });
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    editor: newEditor
+  });
+}
+/**
+ * Toggle feature as layer filter
+ * @memberof visStateUpdaters
+ */
+
+
+function setPolygonFilterLayerUpdater(state, payload) {
+  var layer = payload.layer,
+      feature = payload.feature;
+  var filterId = (0, _utils.getFilterIdInFeature)(feature); // let newFilter = null;
+
+  var filterIdx;
+  var newLayerId = [layer.id];
+  var newState = state; // If polygon filter already exists, we need to find out if the current layer is already included
+
+  if (filterId) {
+    filterIdx = state.filters.findIndex(function (f) {
+      return f.id === filterId;
+    });
+
+    if (!state.filters[filterIdx]) {
+      // what if filter doesn't exist?... not possible.
+      // because features in the editor is passed in from filters and editors.
+      // but we will move this feature back to editor just in case
+      var noneFilterFeature = _objectSpread(_objectSpread({}, feature), {}, {
+        properties: _objectSpread(_objectSpread({}, feature.properties), {}, {
+          filterId: null
+        })
+      });
+
+      return _objectSpread(_objectSpread({}, state), {}, {
+        editor: _objectSpread(_objectSpread({}, state.editor), {}, {
+          features: [].concat((0, _toConsumableArray2["default"])(state.editor.features), [noneFilterFeature]),
+          selectedFeature: noneFilterFeature
+        })
+      });
+    }
+
+    var filter = state.filters[filterIdx];
+    var _filter$layerId = filter.layerId,
+        layerId = _filter$layerId === void 0 ? [] : _filter$layerId;
+    var isLayerIncluded = layerId.includes(layer.id);
+    newLayerId = isLayerIncluded ? // if layer is included, remove it
+    layerId.filter(function (l) {
+      return l !== layer.id;
+    }) : [].concat((0, _toConsumableArray2["default"])(layerId), [layer.id]);
+  } else {
+    // if we haven't create the polygon filter, create it
+    var newFilter = (0, _utils.generatePolygonFilter)([], feature);
+    filterIdx = state.filters.length; // add feature, remove feature from eidtor
+
+    newState = _objectSpread(_objectSpread({}, state), {}, {
+      filters: [].concat((0, _toConsumableArray2["default"])(state.filters), [newFilter]),
+      editor: _objectSpread(_objectSpread({}, state.editor), {}, {
+        features: state.editor.features.filter(function (f) {
+          return f.id !== feature.id;
+        }),
+        selectedFeature: newFilter.value
+      })
+    });
+  }
+
+  return setFilterUpdater(newState, {
+    idx: filterIdx,
+    prop: 'layerId',
+    value: newLayerId
+  });
+}
+/**
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function sortTableColumnUpdater(state, _ref25) {
+  var dataId = _ref25.dataId,
+      column = _ref25.column,
+      mode = _ref25.mode;
+  var dataset = state.datasets[dataId];
+
+  if (!dataset) {
+    return state;
+  }
+
+  var sortMode = mode;
+
+  if (!sortMode) {
+    var currentMode = (0, _lodash3["default"])(dataset, ['sortColumn', column]); // @ts-ignore - should be fixable in a TS file
+
+    sortMode = currentMode ? Object.keys(_constants.SORT_ORDER).find(function (m) {
+      return m !== currentMode;
+    }) : _constants.SORT_ORDER.ASCENDING;
+  }
+
+  var sorted = (0, _table.sortDatasetByColumn)(dataset, column, sortMode);
+  return (0, _utils.set)(['datasets', dataId], sorted, state);
+}
+/**
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function pinTableColumnUpdater(state, _ref26) {
+  var dataId = _ref26.dataId,
+      column = _ref26.column;
+  var dataset = state.datasets[dataId];
+
+  if (!dataset) {
+    return state;
+  }
+
+  var newDataset = (0, _table.pinTableColumns)(dataset, column);
+  return (0, _utils.set)(['datasets', dataId], newDataset, state);
+}
+/**
+ * Copy column content as strings
+ * @memberof visStateUpdaters
+ * @public
+ */
+
+
+function copyTableColumnUpdater(state, _ref27) {
+  var dataId = _ref27.dataId,
+      column = _ref27.column;
+  var dataset = state.datasets[dataId];
+
+  if (!dataset) {
+    return state;
+  }
+
+  var fieldIdx = dataset.fields.findIndex(function (f) {
+    return f.name === column;
+  });
+
+  if (fieldIdx < 0) {
+    return state;
+  }
+
+  var type = dataset.fields[fieldIdx].type;
+  var text = dataset.dataContainer.map(function (row) {
+    return (0, _utils.parseFieldValue)(row.valueAt(fieldIdx), type);
+  }, true).join('\n');
+  (0, _copyToClipboard["default"])(text);
+  return state;
+}
+/**
+ * Update editor
+ */
+
+
+function toggleEditorVisibilityUpdater(state, action) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    editor: _objectSpread(_objectSpread({}, state.editor), {}, {
+      visible: !state.editor.visible
+    })
+  });
+}
+
+function setFilterAnimationTimeConfigUpdater(state, _ref28) {
+  var idx = _ref28.idx,
+      config = _ref28.config;
+  var oldFilter = state.filters[idx];
+
+  if (!oldFilter) {
+    _window.console.error("filters.".concat(idx, " is undefined"));
+
+    return state;
+  }
+
+  if (oldFilter.type !== _constants.FILTER_TYPES.timeRange) {
+    _window.console.error("setFilterAnimationTimeConfig can only be called to update a time filter. check filter.type === 'timeRange'");
+
+    return state;
+  }
+
+  var updates = checkTimeConfigArgs(config);
+  return (0, _composerHelpers.pick_)('filters')((0, _composerHelpers.swap_)((0, _composerHelpers.merge_)(updates)(oldFilter)))(state);
+}
+
+function checkTimeConfigArgs(config) {
+  var allowed = ['timeFormat', 'timezone'];
+  return Object.keys(config).reduce(function (accu, prop) {
+    if (!allowed.includes(prop)) {
+      _window.console.error("setLayerAnimationTimeConfig takes timeFormat and/or timezone as options, found ".concat(prop));
+
+      return accu;
+    } // here we are NOT checking if timezone or timeFormat input is valid
+
+
+    accu[prop] = config[prop];
+    return accu;
+  }, {});
+}
+/**
+ * Update editor
+ */
+
+
+function setLayerAnimationTimeConfigUpdater(state, _ref29) {
+  var config = _ref29.config;
+
+  if (!config) {
+    return state;
+  }
+
+  var updates = checkTimeConfigArgs(config);
+  return (0, _composerHelpers.pick_)('animationConfig')((0, _composerHelpers.merge_)(updates))(state);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/vis-state-updaters.ts"],"names":["visStateUpdaters","defaultInteractionConfig","tooltip","id","label","enabled","config","fieldsToShow","compareMode","compareType","COMPARE_TYPES","ABSOLUTE","geocoder","position","brush","size","coordinate","DEFAULT_ANIMATION_CONFIG","domain","currentTime","speed","isAnimating","timeFormat","timezone","defaultTimeFormat","DEFAULT_EDITOR","mode","EDITOR_MODES","DRAW_POLYGON","features","selectedFeature","visible","INITIAL_VIS_STATE","mapInfo","title","description","layers","layerData","layerToBeMerged","layerOrder","filters","filterToBeMerged","datasets","editingDataset","undefined","interactionConfig","interactionToBeMerged","layerBlending","hoverInfo","clicked","mousePos","maxDefaultTooltips","MAX_DEFAULT_TOOLTIPS","splitMaps","splitMapsToBeMerged","layerClasses","LayerClasses","animationConfig","editor","fileLoading","fileLoadingProgress","loaders","loadOptions","mergers","VIS_STATE_MERGERS","schema","KeplerGLSchema","updateStateWithLayerAndData","state","layer","idx","map","lyr","i","d","updateStateOnLayerVisibilityChange","newState","length","isVisible","animation","updateAnimationDomain","layerConfigChangeUpdater","action","oldLayer","findIndex","l","props","Object","keys","newConfig","dataId","restConfig","stateWithDataId","layerDataIdChangeUpdater","nextLayer","find","newLayer","updateLayerConfig","shouldCalculateLayerData","oldLayerData","updateLayerDataResult","addOrRemoveTextLabels","newFields","textLabel","newTextLabel","slice","currentFields","tl","field","name","filter","addFields","f","includes","deleteFields","fd","DEFAULT_TEXT_LABEL","af","updateTextLabelPropAndValue","prop","value","hasOwnProperty","splice","layerTextLabelChangeUpdater","validateExistingLayerWithData","dataset","loadedLayer","allowEmptyColumn","isValidToSave","validated","type","isConfigActive","updateLayerDomain","setInitialLayerConfig","result","findDefaultLayerProps","Array","isArray","layerTypeChangeUpdater","newType","oldId","Console","error","assignConfigToLayer","visConfigSettings","isLayerHovered","settings","oldLayerMap","otherLayers","layerVisualChannelChangeUpdater","channel","updateLayerVisualChannel","layerVisConfigChangeUpdater","newVisConfig","visConfig","setFilterAnimationTimeUpdater","setFilterUpdater","setFilterAnimationWindowUpdater","animationWindow","valueIndex","oldFilter","newFilter","datasetIds","FILTER_UPDATER_PROPS","datasetId","mergeDomain","updatedFilter","newDataset","gpu","layerId","layerIdDifference","layerDataIds","lid","newDataIds","enlargedFilter","enlarged","datasetIdsToFilter","LIMITED_FILTER_EFFECT_PROPS","filteredDatasets","updateAllLayerDomainData","setFilterPlotUpdater","newProp","plotType","addFilterUpdater","layerColorUIChangeUpdater","oldVixConfig","updateLayerColorUI","toggleFilterAnimationUpdater","toggleLayerAnimationUpdater","toggleLayerAnimationControlUpdater","hideControl","updateFilterAnimationSpeedUpdater","setLayerAnimationTimeUpdater","updateLayerAnimationSpeedUpdater","enlargeFilterUpdater","toggleFilterFeatureUpdater","assign","removeFilterUpdater","newFilters","newEditor","addLayerUpdater","newLayerData","warn","defaultDataset","Layer","removeLayerUpdater","layerToRemove","newMaps","pid","duplicateLayerUpdater","original","originalLayerOrderIdx","newLabel","postfix","LAYER_ID_LENGTH","nextState","newLayerOrderIdx","newLayerOrder","reorderLayerUpdater","order","removeDatasetUpdater","datasetKey","newDatasets","indexes","reduce","listOfIndexes","index","push","currentState","indexCounter","currentIndex","fields","updateLayerBlendingUpdater","showDatasetTableUpdater","updateTableColorUpdater","newColor","existing","updateTableColor","resetMapConfigUpdater","initialState","receiveMapConfigUpdater","payload","version","options","visState","keepExistingConfig","mergedState","merger","merge","layerHoverUpdater","info","interactionConfigChangeUpdater","contradict","forEach","k","layerClickUpdater","pinned","picked","mapClickUpdater","mouseMoveUpdater","evt","values","some","point","mousePosition","lngLat","toggleSplitMapUpdater","closeSpecificMapAtIndex","toggleLayerForMapUpdater","mapIndex","sm","updateVisDataUpdater","newDataEntries","accu","rest","dataEmpty","previousState","toMergeProp","toMerge","newLayers","autoCreateLayers","addDefaultLayers","tooltipFields","addDefaultTooltips","updatedState","renameDatasetUpdater","indexToRetrieve","mapLayers","loadFilesUpdater","files","onFinish","loadFilesSuccess","from","initialFileLoadingProgress","fileCache","filesToLoad","loadNextFileUpdater","loadFileStepSuccessUpdater","fileName","stateWithProgress","updateFileLoadingProgressUpdater","progress","percent","message","stateWithCache","loadNextFile","file","remainingFilesToLoad","makeLoadFileTask","bimap","gen","content","err","processFileContentUpdater","parseProgress","prevProgress","nextFileBatchUpdater","accumulated","next","done","loadFilesErrUpdater","applyCPUFilterUpdater","dataIds","setMapInfoUpdater","empty","defaultLayers","foundLayers","concat","_","merged","fixedDomain","animatableLayers","animationDomain","mergedDomain","Math","min","max","Number","Infinity","setEditorModeUpdater","setFeaturesUpdater","lastFeature","properties","isClosed","EDIT","feature","filterId","featureValue","filterIdx","fil","setSelectedFeatureUpdater","deleteFeatureUpdater","setPolygonFilterLayerUpdater","newLayerId","noneFilterFeature","isLayerIncluded","sortTableColumnUpdater","column","sortMode","currentMode","SORT_ORDER","m","ASCENDING","sorted","pinTableColumnUpdater","copyTableColumnUpdater","fieldIdx","text","dataContainer","row","valueAt","join","toggleEditorVisibilityUpdater","setFilterAnimationTimeConfigUpdater","FILTER_TYPES","timeRange","updates","checkTimeConfigArgs","allowed","setLayerAnimationTimeConfigUpdater"],"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 {console as Console} from 'global/window';\nimport {disableStackCapturing, withTask} from 'react-palm/tasks';\nimport cloneDeep from 'lodash.clonedeep';\nimport uniq from 'lodash.uniq';\nimport get from 'lodash.get';\nimport xor from 'lodash.xor';\nimport copy from 'copy-to-clipboard';\n// Tasks\nimport {LOAD_FILE_TASK, UNWRAP_TASK, PROCESS_FILE_DATA, DELAY_TASK} from '@kepler.gl/tasks';\n// Actions\nimport {\n  loadFilesErr,\n  loadFilesSuccess,\n  loadFileStepSuccess,\n  loadNextFile,\n  nextFileBatch,\n  ReceiveMapConfigPayload,\n  VisStateActions,\n  MapStateActions,\n  processFileContent,\n  ActionTypes\n} from '@kepler.gl/actions';\n\n// Utils\nimport {\n  set,\n  toArray,\n  arrayInsert,\n  generateHashId,\n  addNewLayersToSplitMap,\n  computeSplitMapLayers,\n  removeLayerFromSplitMaps,\n  isRgbColor,\n  parseFieldValue,\n  applyFilterFieldName,\n  applyFiltersToDatasets,\n  featureToFilterValue,\n  filterDatasetCPU,\n  FILTER_UPDATER_PROPS,\n  generatePolygonFilter,\n  getDefaultFilter,\n  getFilterIdInFeature,\n  getTimeWidgetTitleFormatter,\n  isInRange,\n  LIMITED_FILTER_EFFECT_PROPS,\n  updateFilterDataId,\n  getFilterPlot,\n  getDefaultFilterPlotType\n} from '@kepler.gl/utils';\n\nimport {\n  isValidMerger,\n  VIS_STATE_MERGERS,\n  validateLayerWithData,\n  createLayerFromConfig,\n  serializeLayer\n} from './vis-state-merger';\n\nimport {Layer, LayerClasses, LAYER_ID_LENGTH} from '@kepler.gl/layers';\nimport {\n  EDITOR_MODES,\n  SORT_ORDER,\n  FILTER_TYPES,\n  MAX_DEFAULT_TOOLTIPS,\n  DEFAULT_TEXT_LABEL,\n  COMPARE_TYPES\n} from '@kepler.gl/constants';\nimport {pick_, merge_, swap_} from './composer-helpers';\n\nimport KeplerGLSchema, {VisState} from '@kepler.gl/schemas';\n\nimport {Filter, InteractionConfig, AnimationConfig, Editor} from '@kepler.gl/types';\nimport {Loader} from '@loaders.gl/loader-utils';\n\nimport {calculateLayerData, findDefaultLayer} from './layer-utils';\nimport {\n  copyTableAndUpdate,\n  Datasets,\n  pinTableColumns,\n  sortDatasetByColumn,\n  assignGpuChannel,\n  setFilterGpuMode,\n  createNewDataEntry\n} from '@kepler.gl/table';\nimport {findFieldsToShow} from './interaction-utils';\n\n// react-palm\n// disable capture exception for react-palm call to withTask\ndisableStackCapturing();\n\n/**\n * Updaters for `visState` reducer. Can be used in your root reducer to directly modify kepler.gl's state.\n * Read more about [Using updaters](../advanced-usage/using-updaters.md)\n *\n * @public\n * @example\n *\n * import keplerGlReducer, {visStateUpdaters} 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 *    case 'CLICK_BUTTON':\n *      return {\n *        ...state,\n *        keplerGl: {\n *          ...state.keplerGl,\n *          foo: {\n *             ...state.keplerGl.foo,\n *             visState: visStateUpdaters.enlargeFilterUpdater(\n *               state.keplerGl.foo.visState,\n *               {idx: 0}\n *             )\n *          }\n *        }\n *      };\n *  }\n *  return reducers(state, action);\n * };\n *\n * export default composedReducer;\n */\n/* eslint-disable no-unused-vars */\n// @ts-ignore\nconst visStateUpdaters = null;\n/* eslint-enable no-unused-vars */\n\nexport const defaultInteractionConfig: InteractionConfig = {\n  tooltip: {\n    id: 'tooltip',\n    label: 'interactions.tooltip',\n    enabled: true,\n    config: {\n      fieldsToShow: {},\n      compareMode: false,\n      compareType: COMPARE_TYPES.ABSOLUTE\n    }\n  },\n  geocoder: {\n    id: 'geocoder',\n    label: 'interactions.geocoder',\n    enabled: false,\n    position: null\n  },\n  brush: {\n    id: 'brush',\n    label: 'interactions.brush',\n    enabled: false,\n    config: {\n      // size is in km\n      size: 0.5\n    }\n  },\n  coordinate: {\n    id: 'coordinate',\n    label: 'interactions.coordinate',\n    enabled: false,\n    position: null\n  }\n};\n\nexport const DEFAULT_ANIMATION_CONFIG: AnimationConfig = {\n  domain: null,\n  currentTime: null,\n  speed: 1,\n  isAnimating: false,\n  timeFormat: null,\n  timezone: null,\n  defaultTimeFormat: null\n};\n\nexport const DEFAULT_EDITOR: Editor = {\n  mode: EDITOR_MODES.DRAW_POLYGON,\n  features: [],\n  selectedFeature: null,\n  visible: true\n};\n\n/**\n * Default initial `visState`\n * @memberof visStateUpdaters\n * @constant\n * @public\n */\nexport const INITIAL_VIS_STATE: VisState = {\n  // map info\n  mapInfo: {\n    title: '',\n    description: ''\n  },\n  // layers\n  layers: [],\n  layerData: [],\n  layerToBeMerged: [],\n  layerOrder: [],\n\n  // filters\n  filters: [],\n  filterToBeMerged: [],\n\n  // a collection of multiple dataset\n  datasets: {},\n  editingDataset: undefined,\n\n  interactionConfig: defaultInteractionConfig,\n  interactionToBeMerged: undefined,\n\n  layerBlending: 'normal',\n  hoverInfo: undefined,\n  clicked: undefined,\n  mousePos: {},\n  maxDefaultTooltips: MAX_DEFAULT_TOOLTIPS,\n\n  // this is used when user split maps\n  splitMaps: [\n    // this will contain a list of objects to\n    // describe the state of layer availability and visibility for each map\n    // [\n    //   {\n    //      layers: {layer_id: true | false}\n    //   }\n    // ]\n  ],\n  splitMapsToBeMerged: [],\n\n  // defaults layer classes\n  layerClasses: LayerClasses,\n\n  // default animation\n  // time in unix timestamp (milliseconds) (the number of seconds since the Unix Epoch)\n  animationConfig: DEFAULT_ANIMATION_CONFIG,\n\n  editor: DEFAULT_EDITOR,\n\n  fileLoading: false,\n  fileLoadingProgress: {},\n\n  loaders: [],\n  loadOptions: {},\n\n  // visStateMergers\n  mergers: VIS_STATE_MERGERS,\n\n  // kepler schemas\n  schema: KeplerGLSchema\n};\n\n/**\n * Update state with updated layer and layerData\n *\n */\nexport function updateStateWithLayerAndData(\n  state: VisState,\n  {layerData, layer, idx}: {layerData?: any; layer: Layer; idx: number}\n): VisState {\n  return {\n    ...state,\n    layers: state.layers.map((lyr, i) => (i === idx ? layer : lyr)),\n    layerData: layerData\n      ? state.layerData.map((d, i) => (i === idx ? layerData : d))\n      : state.layerData\n  };\n}\n\nexport function updateStateOnLayerVisibilityChange<S extends VisState>(state: S, layer: Layer): S {\n  let newState = state;\n  if (state.splitMaps.length) {\n    newState = {\n      ...state,\n      splitMaps: layer.config.isVisible\n        ? addNewLayersToSplitMap(state.splitMaps, layer)\n        : removeLayerFromSplitMaps(state.splitMaps, layer)\n    };\n  }\n\n  if (layer.config.animation.enabled) {\n    newState = updateAnimationDomain(state);\n  }\n\n  return newState;\n}\n\n/**\n * Update layer base config: dataId, label, column, isVisible\n * @memberof visStateUpdaters\n * @returns nextState\n */\nexport function layerConfigChangeUpdater(\n  state: VisState,\n  action: VisStateActions.LayerConfigChangeUpdaterAction\n): VisState {\n  const {oldLayer} = action;\n  const idx = state.layers.findIndex(l => l.id === oldLayer.id);\n  const props = Object.keys(action.newConfig);\n  if (typeof action.newConfig.dataId === 'string') {\n    const {dataId, ...restConfig} = action.newConfig;\n    const stateWithDataId = layerDataIdChangeUpdater(state, {\n      oldLayer,\n      newConfig: {dataId}\n    });\n    const nextLayer = stateWithDataId.layers.find(l => l.id === oldLayer.id);\n    return nextLayer && Object.keys(restConfig).length\n      ? layerConfigChangeUpdater(stateWithDataId, {oldLayer: nextLayer, newConfig: restConfig})\n      : stateWithDataId;\n  }\n\n  let newLayer = oldLayer.updateLayerConfig(action.newConfig);\n\n  let layerData;\n\n  // let newLayer;\n  if (newLayer.shouldCalculateLayerData(props)) {\n    const oldLayerData = state.layerData[idx];\n    const updateLayerDataResult = calculateLayerData(newLayer, state, oldLayerData);\n\n    layerData = updateLayerDataResult.layerData;\n    newLayer = updateLayerDataResult.layer;\n  }\n\n  let newState = state;\n  if ('isVisible' in action.newConfig) {\n    newState = updateStateOnLayerVisibilityChange(state, newLayer);\n  }\n\n  return updateStateWithLayerAndData(newState, {\n    layer: newLayer,\n    layerData,\n    idx\n  });\n}\n\nfunction addOrRemoveTextLabels(newFields, textLabel) {\n  let newTextLabel = textLabel.slice();\n\n  const currentFields = textLabel.map(tl => tl.field && tl.field.name).filter(d => d);\n\n  const addFields = newFields.filter(f => !currentFields.includes(f.name));\n  const deleteFields = currentFields.filter(f => !newFields.find(fd => fd.name === f));\n\n  // delete\n  newTextLabel = newTextLabel.filter(tl => tl.field && !deleteFields.includes(tl.field.name));\n  newTextLabel = !newTextLabel.length ? [DEFAULT_TEXT_LABEL] : newTextLabel;\n\n  // add\n  newTextLabel = [\n    ...newTextLabel.filter(tl => tl.field),\n    ...addFields.map(af => ({\n      ...DEFAULT_TEXT_LABEL,\n      field: af\n    }))\n  ];\n\n  return newTextLabel;\n}\n\nfunction updateTextLabelPropAndValue(idx, prop, value, textLabel) {\n  if (!textLabel[idx].hasOwnProperty(prop)) {\n    return textLabel;\n  }\n\n  let newTextLabel = textLabel.slice();\n\n  if (prop && (value || textLabel.length === 1)) {\n    newTextLabel = textLabel.map((tl, i) => (i === idx ? {...tl, [prop]: value} : tl));\n  } else if (prop === 'field' && value === null && textLabel.length > 1) {\n    // remove label when field value is set to null\n    newTextLabel.splice(idx, 1);\n  }\n\n  return newTextLabel;\n}\n\n/**\n * Update layer base config: dataId, label, column, isVisible\n * @memberof visStateUpdaters\n * @returns nextState\n */\nexport function layerTextLabelChangeUpdater(\n  state: VisState,\n  action: VisStateActions.LayerTextLabelChangeUpdaterAction\n): VisState {\n  const {oldLayer, idx, prop, value} = action;\n  const {textLabel} = oldLayer.config;\n\n  let newTextLabel = textLabel.slice();\n  if (!textLabel[idx] && idx === textLabel.length) {\n    // if idx is set to length, add empty text label\n    newTextLabel = [...textLabel, DEFAULT_TEXT_LABEL];\n  }\n\n  if (idx === 'all' && prop === 'fields') {\n    newTextLabel = addOrRemoveTextLabels(value, textLabel);\n  } else {\n    newTextLabel = updateTextLabelPropAndValue(idx, prop, value, newTextLabel);\n  }\n  // update text label prop and value\n  return layerConfigChangeUpdater(state, {\n    oldLayer,\n    newConfig: {textLabel: newTextLabel}\n  });\n}\n\nfunction validateExistingLayerWithData(dataset, layerClasses, layer) {\n  const loadedLayer = serializeLayer(layer);\n  return validateLayerWithData(dataset, loadedLayer, layerClasses, {\n    allowEmptyColumn: true\n  });\n}\n\n/**\n * Update layer config dataId\n * @memberof visStateUpdaters\n * @returns nextState\n */\nexport function layerDataIdChangeUpdater(\n  state: VisState,\n  action: {\n    oldLayer: Layer;\n    newConfig: {\n      dataId: string;\n    };\n  }\n): VisState {\n  const {oldLayer, newConfig} = action;\n  const {dataId} = newConfig;\n\n  if (!oldLayer || !state.datasets[dataId]) {\n    return state;\n  }\n  const idx = state.layers.findIndex(l => l.id === oldLayer.id);\n\n  let newLayer = oldLayer.updateLayerConfig({dataId});\n  // this may happen when a layer is new (type: null and no columns) but it's not ready to be saved\n  if (newLayer.isValidToSave()) {\n    const validated = validateExistingLayerWithData(\n      state.datasets[dataId],\n      state.layerClasses,\n      newLayer\n    );\n    // if cant validate it with data create a new one\n    if (!validated) {\n      // @ts-expect-error TODO: checking oldLayer.type !== null\n      newLayer = new state.layerClasses[oldLayer.type]({dataId, id: oldLayer.id});\n    } else {\n      newLayer = validated;\n    }\n  }\n\n  newLayer = newLayer.updateLayerConfig({\n    isVisible: oldLayer.config.isVisible,\n    isConfigActive: true\n  });\n\n  newLayer.updateLayerDomain(state.datasets);\n  const {layerData, layer} = calculateLayerData(newLayer, state, undefined);\n\n  return updateStateWithLayerAndData(state, {layerData, layer, idx});\n}\n\nfunction setInitialLayerConfig(layer, datasets, layerClasses) {\n  let newLayer = layer;\n  if (!Object.keys(datasets).length) {\n    // no data is loaded\n    return layer;\n  }\n  if (!layer.config.dataId) {\n    // set layer dataId\n    newLayer = layer.updateLayerConfig({dataId: Object.keys(datasets)[0]});\n  }\n  const dataset = datasets[newLayer.config.dataId];\n  if (!dataset) {\n    return layer;\n  }\n\n  // find defaut layer props\n  const result =\n    typeof layerClasses[newLayer.type].findDefaultLayerProps === 'function'\n      ? layerClasses[newLayer.type].findDefaultLayerProps(dataset, [])\n      : {props: []};\n\n  // an array of possible props, use 1st one\n  const props = Array.isArray(result) ? result : result.props || [];\n\n  if (props.length) {\n    newLayer = new layerClasses[layer.type]({\n      ...props[0],\n      label: newLayer.config.label,\n      dataId: newLayer.config.dataId,\n      isVisible: true,\n      isConfigActive: newLayer.config.isConfigActive\n    });\n\n    return typeof newLayer.setInitialLayerConfig === 'function'\n      ? newLayer.setInitialLayerConfig(dataset)\n      : newLayer;\n  }\n\n  return newLayer;\n}\n/**\n * Update layer type. Previews layer config will be copied if applicable.\n * @memberof visStateUpdaters\n * @public\n */\nexport function layerTypeChangeUpdater(\n  state: VisState,\n  action: VisStateActions.LayerTypeChangeUpdaterAction\n): VisState {\n  const {oldLayer, newType} = action;\n  if (!oldLayer) {\n    return state;\n  }\n  const oldId = oldLayer.id;\n  const idx = state.layers.findIndex(l => l.id === oldId);\n\n  if (!state.layerClasses[newType]) {\n    Console.error(`${newType} is not a valid layer type`);\n    return state;\n  }\n  let newLayer = new state.layerClasses[newType]({\n    // keep old layer lable and isConfigActive\n    label: oldLayer.config.label,\n    isConfigActive: oldLayer.config.isConfigActive\n  });\n\n  if (!oldLayer.type) {\n    // if setting layer type on an empty layer\n    newLayer = setInitialLayerConfig(newLayer, state.datasets, state.layerClasses);\n  } else {\n    // get a mint layer, with new id and type\n    // because deck.gl uses id to match between new and old layer.\n    // If type has changed but id is the same, it will break\n    newLayer.assignConfigToLayer(oldLayer.config, oldLayer.visConfigSettings);\n    newLayer.updateLayerDomain(state.datasets);\n  }\n\n  const {clicked, hoverInfo} = state;\n\n  let newState = {\n    ...state,\n    clicked: oldLayer.isLayerHovered(clicked) ? undefined : clicked,\n    hoverInfo: oldLayer.isLayerHovered(hoverInfo) ? undefined : hoverInfo\n  };\n\n  const {layerData, layer} = calculateLayerData(newLayer, newState);\n  newState = updateStateWithLayerAndData(newState, {layerData, layer, idx});\n\n  if (layer.config.animation.enabled || oldLayer.config.animation.enabled) {\n    newState = updateAnimationDomain(newState);\n  }\n\n  // update splitMap layer id\n  if (state.splitMaps.length) {\n    newState = {\n      ...newState,\n      splitMaps: newState.splitMaps.map(settings => {\n        const {[oldId]: oldLayerMap, ...otherLayers} = settings.layers;\n        return oldId in settings.layers\n          ? {\n              ...settings,\n              layers: {\n                ...otherLayers,\n                [layer.id]: oldLayerMap\n              }\n            }\n          : settings;\n      })\n    };\n  }\n\n  return newState;\n}\n\n/**\n * Update layer visual channel\n * @memberof visStateUpdaters\n * @returns {Object} nextState\n * @public\n */\nexport function layerVisualChannelChangeUpdater(\n  state: VisState,\n  action: VisStateActions.LayerVisualChannelConfigChangeUpdaterAction\n): VisState {\n  const {oldLayer, newConfig, channel} = action;\n  if (!oldLayer.config.dataId) {\n    return state;\n  }\n  const dataset = state.datasets[oldLayer.config.dataId];\n\n  const idx = state.layers.findIndex(l => l.id === oldLayer.id);\n  const newLayer = oldLayer.updateLayerConfig(newConfig);\n\n  newLayer.updateLayerVisualChannel(dataset, channel);\n\n  const oldLayerData = state.layerData[idx];\n  const {layerData, layer} = calculateLayerData(newLayer, state, oldLayerData);\n\n  return updateStateWithLayerAndData(state, {layerData, layer, idx});\n}\n\n/**\n * Update layer `visConfig`\n * @memberof visStateUpdaters\n * @public\n */\nexport function layerVisConfigChangeUpdater(\n  state: VisState,\n  action: VisStateActions.LayerVisConfigChangeUpdaterAction\n): VisState {\n  const {oldLayer} = action;\n  const idx = state.layers.findIndex(l => l.id === oldLayer.id);\n  const props = Object.keys(action.newVisConfig);\n  const newVisConfig = {\n    ...oldLayer.config.visConfig,\n    ...action.newVisConfig\n  };\n\n  const newLayer = oldLayer.updateLayerConfig({visConfig: newVisConfig});\n\n  if (newLayer.shouldCalculateLayerData(props)) {\n    const oldLayerData = state.layerData[idx];\n    const {layerData, layer} = calculateLayerData(newLayer, state, oldLayerData);\n    return updateStateWithLayerAndData(state, {layerData, layer, idx});\n  }\n\n  return updateStateWithLayerAndData(state, {layer: newLayer, idx});\n}\n\n/**\n * Update filter property\n * @memberof visStateUpdaters\n * @public\n */\nexport function setFilterAnimationTimeUpdater(\n  state: VisState,\n  action: VisStateActions.SetFilterAnimationTimeUpdaterAction\n): VisState {\n  return setFilterUpdater(state, action);\n}\n\n/**\n * Update filter animation window\n * @memberof visStateUpdaters\n * @public\n */\nexport function setFilterAnimationWindowUpdater(\n  state: VisState,\n  {id, animationWindow}: VisStateActions.SetFilterAnimationWindowUpdaterAction\n): VisState {\n  return {\n    ...state,\n    filters: state.filters.map(f =>\n      f.id === id\n        ? {\n            ...f,\n            animationWindow\n          }\n        : f\n    )\n  };\n}\n/**\n * Update filter property\n * @memberof visStateUpdaters\n * @public\n */\nexport function setFilterUpdater(\n  state: VisState,\n  action: VisStateActions.SetFilterUpdaterAction\n): VisState {\n  const {idx, prop, value, valueIndex = 0} = action;\n  const oldFilter = state.filters[idx];\n\n  if (!oldFilter) {\n    Console.error(`filters.${idx} is undefined`);\n    return state;\n  }\n  let newFilter = set([prop], value, oldFilter);\n  let newState = state;\n\n  const {dataId} = newFilter;\n\n  // Ensuring backward compatibility\n  let datasetIds = toArray(dataId);\n\n  switch (prop) {\n    // TODO: Next PR for UI if we update dataId, we need to consider two cases:\n    // 1. dataId is empty: create a default filter\n    // 2. Add a new dataset id\n    case FILTER_UPDATER_PROPS.dataId:\n      // if trying to update filter dataId. create an empty new filter\n      newFilter = updateFilterDataId(dataId);\n      break;\n\n    case FILTER_UPDATER_PROPS.name:\n      // we are supporting the current functionality\n      // TODO: Next PR for UI filter name will only update filter name but it won't have side effects\n      // we are gonna use pair of datasets and fieldIdx to update the filter\n      const datasetId = newFilter.dataId[valueIndex];\n      const {filter: updatedFilter, dataset: newDataset} = applyFilterFieldName(\n        newFilter,\n        state.datasets[datasetId],\n        value,\n        valueIndex,\n        {mergeDomain: false}\n      );\n      if (!updatedFilter) {\n        return state;\n      }\n\n      newFilter = updatedFilter;\n\n      if (newFilter.gpu) {\n        newFilter = setFilterGpuMode(newFilter, state.filters);\n        newFilter = assignGpuChannel(newFilter, state.filters);\n      }\n\n      newState = set(['datasets', datasetId], newDataset, state);\n\n      // only filter the current dataset\n      break;\n    case FILTER_UPDATER_PROPS.layerId:\n      // We need to update only datasetId/s if we have added/removed layers\n      // - check for layerId changes (XOR works because of string values)\n      // if no differences between layerIds, don't do any filtering\n      // @ts-ignore\n      const layerIdDifference = xor(newFilter.layerId, oldFilter.layerId);\n\n      const layerDataIds = uniq(\n        layerIdDifference\n          .map(lid =>\n            get(\n              state.layers.find(l => l.id === lid),\n              ['config', 'dataId']\n            )\n          )\n          .filter(d => d)\n      );\n\n      // only filter datasetsIds\n      datasetIds = layerDataIds;\n\n      // Update newFilter dataIds\n      const newDataIds = uniq(\n        newFilter.layerId\n          .map(lid =>\n            get(\n              state.layers.find(l => l.id === lid),\n              ['config', 'dataId']\n            )\n          )\n          .filter(d => d)\n      );\n\n      newFilter = {\n        ...newFilter,\n        dataId: newDataIds\n      };\n\n      break;\n    default:\n      break;\n  }\n\n  const enlargedFilter = state.filters.find(f => f.enlarged);\n\n  if (enlargedFilter && enlargedFilter.id !== newFilter.id) {\n    // there should be only one enlarged filter\n    newFilter.enlarged = false;\n  }\n\n  // save new filters to newState\n  newState = set(['filters', idx], newFilter, newState);\n\n  // if we are currently setting a prop that only requires to filter the current\n  // dataset we will pass only the current dataset to applyFiltersToDatasets and\n  // updateAllLayerDomainData otherwise we pass the all list of datasets as defined in dataId\n  const datasetIdsToFilter = LIMITED_FILTER_EFFECT_PROPS[prop]\n    ? [datasetIds[valueIndex]]\n    : datasetIds;\n\n  // filter data\n  const filteredDatasets = applyFiltersToDatasets(\n    datasetIdsToFilter,\n    newState.datasets,\n    newState.filters,\n    newState.layers\n  );\n\n  newState = set(['datasets'], filteredDatasets, newState);\n  // dataId is an array\n  // pass only the dataset we need to update\n  newState = updateAllLayerDomainData(newState, datasetIdsToFilter, newFilter);\n\n  return newState;\n}\n\n/**\n * Set the property of a filter plot\n * @memberof visStateUpdaters\n * @public\n */\nexport const setFilterPlotUpdater = (\n  state: VisState,\n  {idx, newProp, valueIndex = 0}: VisStateActions.SetFilterPlotUpdaterAction\n): VisState => {\n  let newFilter = {...state.filters[idx], ...newProp};\n  const prop = Object.keys(newProp)[0];\n  if (prop === 'yAxis') {\n    const plotType = getDefaultFilterPlotType(newFilter);\n    // TODO: plot is not supported in multi dataset filter for now\n    if (plotType) {\n      newFilter = {\n        ...newFilter,\n        ...getFilterPlot({...newFilter, plotType}, state.datasets[newFilter.dataId[valueIndex]]),\n        plotType\n      };\n    }\n  }\n\n  return {\n    ...state,\n    filters: state.filters.map((f, i) => (i === idx ? newFilter : f))\n  };\n};\n\n/**\n * Add a new filter\n * @memberof visStateUpdaters\n * @public\n */\nexport const addFilterUpdater = (\n  state: VisState,\n  action: VisStateActions.AddFilterUpdaterAction\n): VisState =>\n  !action.dataId\n    ? state\n    : {\n        ...state,\n        filters: [...state.filters, getDefaultFilter(action.dataId)]\n      };\n\n/**\n * Set layer color palette ui state\n * @memberof visStateUpdaters\n */\nexport const layerColorUIChangeUpdater = (\n  state: VisState,\n  {oldLayer, prop, newConfig}: VisStateActions.LayerColorUIChangeUpdaterAction\n): VisState => {\n  const oldVixConfig = oldLayer.config.visConfig[prop];\n  const newLayer = oldLayer.updateLayerColorUI(prop, newConfig);\n  const newVisConfig = newLayer.config.visConfig[prop];\n  if (oldVixConfig !== newVisConfig) {\n    return layerVisConfigChangeUpdater(state, {\n      oldLayer,\n      newVisConfig: {\n        [prop]: newVisConfig\n      }\n    });\n  }\n  return {\n    ...state,\n    layers: state.layers.map(l => (l.id === oldLayer.id ? newLayer : l))\n  };\n};\n\n/**\n * Start and end filter animation\n * @memberof visStateUpdaters\n * @public\n */\nexport const toggleFilterAnimationUpdater = (\n  state: VisState,\n  action: VisStateActions.ToggleFilterAnimationUpdaterAction\n): VisState => ({\n  ...state,\n  filters: state.filters.map((f, i) => (i === action.idx ? {...f, isAnimating: !f.isAnimating} : f))\n});\n\n/**\n * @memberof visStateUpdaters\n * @public\n */\nexport const toggleLayerAnimationUpdater = (\n  state: VisState,\n  action: VisStateActions.ToggleLayerAnimationUpdaterAction\n): VisState => ({\n  ...state,\n  animationConfig: {\n    ...state.animationConfig,\n    isAnimating: !state.animationConfig.isAnimating\n  }\n});\n\n/**\n * Hide and show layer animation control\n * @memberof visStateUpdaters\n * @public\n */\nexport const toggleLayerAnimationControlUpdater = (\n  state: VisState,\n  action: VisStateActions.ToggleLayerAnimationControlUpdaterAction\n): VisState => ({\n  ...state,\n  animationConfig: {\n    ...state.animationConfig,\n    hideControl: !state.animationConfig.hideControl\n  }\n});\n\n/**\n * Change filter animation speed\n * @memberof visStateUpdaters\n * @public\n */\nexport const updateFilterAnimationSpeedUpdater = (\n  state: VisState,\n  action: VisStateActions.UpdateFilterAnimationSpeedUpdaterAction\n): VisState => ({\n  ...state,\n  filters: state.filters.map((f, i) => (i === action.idx ? {...f, speed: action.speed} : f))\n});\n\n/**\n * Reset animation config current time to a specified value\n * @memberof visStateUpdaters\n * @public\n *\n */\nexport const setLayerAnimationTimeUpdater = (\n  state: VisState,\n  {value}: VisStateActions.SetLayerAnimationTimeUpdaterAction\n): VisState => ({\n  ...state,\n  animationConfig: {\n    ...state.animationConfig,\n    currentTime: value\n  }\n});\n\n/**\n * Update animation speed with the vertical speed slider\n * @memberof visStateUpdaters\n * @public\n *\n */\nexport const updateLayerAnimationSpeedUpdater = (\n  state: VisState,\n  {speed}: VisStateActions.UpdateLayerAnimationSpeedUpdaterAction\n): VisState => {\n  return {\n    ...state,\n    animationConfig: {\n      ...state.animationConfig,\n      speed\n    }\n  };\n};\n\n/**\n * Show larger time filter at bottom for time playback (apply to time filter only)\n * @memberof visStateUpdaters\n * @public\n */\nexport const enlargeFilterUpdater = (\n  state: VisState,\n  action: VisStateActions.EnlargeFilterUpdaterAction\n): VisState => {\n  return {\n    ...state,\n    filters: state.filters.map((f, i) =>\n      i === action.idx\n        ? {\n            ...f,\n            enlarged: !f.enlarged\n          }\n        : f\n    )\n  };\n};\n\n/**\n * Toggles filter feature visibility\n * @memberof visStateUpdaters\n */\nexport const toggleFilterFeatureUpdater = (\n  state: VisState,\n  action: VisStateActions.ToggleFilterFeatureUpdaterAction\n): VisState => {\n  const filter = state.filters[action.idx];\n  const isVisible = get(filter, ['value', 'properties', 'isVisible']);\n  const newFilter = {\n    ...filter,\n    value: featureToFilterValue(filter.value, filter.id, {\n      isVisible: !isVisible\n    })\n  };\n\n  return {\n    ...state,\n    filters: Object.assign([...state.filters], {[action.idx]: newFilter})\n  };\n};\n\n/**\n * Remove a filter\n * @memberof visStateUpdaters\n * @public\n */\nexport const removeFilterUpdater = (\n  state: VisState,\n  action: VisStateActions.RemoveFilterUpdaterAction\n): VisState => {\n  const {idx} = action;\n  const {dataId, id} = state.filters[idx];\n\n  const newFilters = [\n    ...state.filters.slice(0, idx),\n    ...state.filters.slice(idx + 1, state.filters.length)\n  ];\n\n  const filteredDatasets = applyFiltersToDatasets(dataId, state.datasets, newFilters, state.layers);\n  const newEditor =\n    getFilterIdInFeature(state.editor.selectedFeature) === id\n      ? {\n          ...state.editor,\n          selectedFeature: null\n        }\n      : state.editor;\n\n  let newState = set(['filters'], newFilters, state);\n  newState = set(['datasets'], filteredDatasets, newState);\n  newState = set(['editor'], newEditor, newState);\n\n  return updateAllLayerDomainData(newState, dataId, undefined);\n};\n\n/**\n * Add a new layer\n * @memberof visStateUpdaters\n * @public\n */\nexport const addLayerUpdater = (\n  state: VisState,\n  action: VisStateActions.AddLayerUpdaterAction\n): VisState => {\n  let newLayer;\n  let newLayerData;\n  if (action.config) {\n    newLayer = createLayerFromConfig(state, action.config);\n    if (!newLayer) {\n      Console.warn(\n        'Failed to create layer from config, it usually means the config is not be in correct format',\n        action.config\n      );\n      return state;\n    }\n\n    const result = calculateLayerData(newLayer, state);\n    newLayer = result.layer;\n    newLayerData = result.layerData;\n  } else {\n    // create an empty layer with a specific dataset or a default one\n    const defaultDataset = action.datasetId ?? Object.keys(state.datasets)[0];\n    newLayer = new Layer({\n      isVisible: true,\n      isConfigActive: true,\n      dataId: defaultDataset\n    });\n    newLayerData = {};\n  }\n  return {\n    ...state,\n    layers: [...state.layers, newLayer],\n    layerData: [...state.layerData, newLayerData],\n    layerOrder: [...state.layerOrder, state.layerOrder.length],\n    splitMaps: addNewLayersToSplitMap(state.splitMaps, newLayer)\n  };\n};\n\n/**\n * remove layer\n * @memberof visStateUpdaters\n * @public\n */\nexport const removeLayerUpdater = (\n  state: VisState,\n  {idx}: VisStateActions.RemoveLayerUpdaterAction\n): VisState => {\n  const {layers, layerData, clicked, hoverInfo} = state;\n  const layerToRemove = state.layers[idx];\n  const newMaps = removeLayerFromSplitMaps(state.splitMaps, layerToRemove);\n\n  const newState = {\n    ...state,\n    layers: [...layers.slice(0, idx), ...layers.slice(idx + 1, layers.length)],\n    layerData: [...layerData.slice(0, idx), ...layerData.slice(idx + 1, layerData.length)],\n    layerOrder: state.layerOrder.filter(i => i !== idx).map(pid => (pid > idx ? pid - 1 : pid)),\n    clicked: layerToRemove.isLayerHovered(clicked) ? undefined : clicked,\n    hoverInfo: layerToRemove.isLayerHovered(hoverInfo) ? undefined : hoverInfo,\n    splitMaps: newMaps\n    // TODO: update filters, create helper to remove layer form filter (remove layerid and dataid) if mapped\n  };\n\n  return updateAnimationDomain(newState);\n};\n\n/**\n * duplicate layer\n * @memberof visStateUpdaters\n * @public\n */\nexport const duplicateLayerUpdater = (\n  state: VisState,\n  {idx}: VisStateActions.DuplicateLayerUpdaterAction\n): VisState => {\n  const {layers} = state;\n  const original = state.layers[idx];\n  const originalLayerOrderIdx = state.layerOrder.findIndex(i => i === idx);\n\n  if (!original) {\n    Console.warn(`layer.${idx} is undefined`);\n    return state;\n  }\n  let newLabel = `Copy of ${original.config.label}`;\n  let postfix = 0;\n  // eslint-disable-next-line no-loop-func\n  while (layers.find(l => l.config.label === newLabel)) {\n    newLabel = `Copy of ${original.config.label} ${++postfix}`;\n  }\n\n  // collect layer config from original\n  const loadedLayer = serializeLayer(original);\n\n  // assign new id and label to copied layer\n  if (!loadedLayer?.config) {\n    return state;\n  }\n  loadedLayer.config.label = newLabel;\n  loadedLayer.id = generateHashId(LAYER_ID_LENGTH);\n\n  // add layer to state\n  let nextState = addLayerUpdater(state, {config: loadedLayer});\n\n  // new added layer are at the end, move it to be on top of original layer\n  const newLayerOrderIdx = nextState.layerOrder.length - 1;\n  const newLayerOrder = arrayInsert(\n    nextState.layerOrder.slice(0, newLayerOrderIdx),\n    originalLayerOrderIdx,\n    newLayerOrderIdx\n  );\n\n  nextState = {\n    ...nextState,\n    layerOrder: newLayerOrder\n  };\n\n  return updateAnimationDomain(nextState);\n};\n\n/**\n * Reorder layer\n * @memberof visStateUpdaters\n * @public\n */\nexport const reorderLayerUpdater = (\n  state: VisState,\n  {order}: VisStateActions.ReorderLayerUpdaterAction\n): VisState => ({\n  ...state,\n  layerOrder: order\n});\n\n/**\n * Remove a dataset and all layers, filters, tooltip configs that based on it\n * @memberof visStateUpdaters\n * @public\n */\nexport const removeDatasetUpdater = (\n  state: VisState,\n  action: VisStateActions.RemoveDatasetUpdaterAction\n): VisState => {\n  // extract dataset key\n  const {dataId: datasetKey} = action;\n  const {datasets} = state;\n\n  // check if dataset is present\n  if (!datasets[datasetKey]) {\n    return state;\n  }\n\n  /* eslint-disable no-unused-vars */\n  const {\n    layers,\n    datasets: {[datasetKey]: dataset, ...newDatasets}\n  } = state;\n  /* eslint-enable no-unused-vars */\n\n  const indexes = layers.reduce((listOfIndexes, layer, index) => {\n    if (layer.config.dataId === datasetKey) {\n      // @ts-ignore\n      listOfIndexes.push(index);\n    }\n    return listOfIndexes;\n  }, []);\n\n  // remove layers and datasets\n  const {newState} = indexes.reduce(\n    ({newState: currentState, indexCounter}, idx) => {\n      const currentIndex = idx - indexCounter;\n      currentState = removeLayerUpdater(currentState, {idx: currentIndex});\n      indexCounter++;\n      return {newState: currentState, indexCounter};\n    },\n    {newState: {...state, datasets: newDatasets}, indexCounter: 0}\n  );\n\n  // remove filters\n  const filters = state.filters.filter(filter => !filter.dataId.includes(datasetKey));\n\n  // update interactionConfig\n  let {interactionConfig} = state;\n  const {tooltip} = interactionConfig;\n  if (tooltip) {\n    const {config} = tooltip;\n    /* eslint-disable no-unused-vars */\n    const {[datasetKey]: fields, ...fieldsToShow} = config.fieldsToShow;\n    /* eslint-enable no-unused-vars */\n    interactionConfig = {\n      ...interactionConfig,\n      tooltip: {...tooltip, config: {...config, fieldsToShow}}\n    };\n  }\n\n  return {...newState, filters, interactionConfig};\n};\n\n/**\n * update layer blending mode\n * @memberof visStateUpdaters\n * @public\n */\nexport const updateLayerBlendingUpdater = (\n  state: VisState,\n  action: VisStateActions.UpdateLayerBlendingUpdaterAction\n): VisState => ({\n  ...state,\n  layerBlending: action.mode\n});\n\n/**\n * Display dataset table in a modal\n * @memberof visStateUpdaters\n * @public\n */\nexport const showDatasetTableUpdater = (\n  state: VisState,\n  action: VisStateActions.ShowDatasetTableUpdaterAction\n): VisState => {\n  return {\n    ...state,\n    editingDataset: action.dataId\n  };\n};\n\n/**\n * Add custom color for datasets and layers\n * @memberof visStateUpdaters\n * @public\n */\nexport const updateTableColorUpdater = (\n  state: VisState,\n  action: VisStateActions.UpdateDatasetColorUpdater\n): VisState => {\n  const {dataId, newColor} = action;\n  const {datasets} = state;\n\n  if (isRgbColor(newColor)) {\n    const existing = datasets[dataId];\n    existing.updateTableColor(newColor);\n\n    return {\n      ...state,\n      datasets: {\n        ...state.datasets,\n        [dataId]: copyTableAndUpdate(existing, {})\n      }\n    };\n  }\n  return state;\n};\n\n/**\n * reset visState to initial State\n * @memberof visStateUpdaters\n * @public\n */\nexport const resetMapConfigUpdater = (state: VisState): VisState => ({\n  ...INITIAL_VIS_STATE,\n  ...state.initialState,\n  initialState: state.initialState\n});\n\n/**\n * Propagate `visState` reducer with a new configuration. Current config will be override.\n * @memberof visStateUpdaters\n * @public\n */\nexport const receiveMapConfigUpdater = (\n  state: VisState,\n  {\n    payload: {config = {version: ''}, options = {}}\n  }: {\n    type?: typeof ActionTypes.RECEIVE_MAP_CONFIG;\n    payload: ReceiveMapConfigPayload;\n  }\n): VisState => {\n  if (!config.visState) {\n    return state;\n  }\n\n  const {keepExistingConfig} = options;\n\n  // reset config if keepExistingConfig is falsy\n  let mergedState = !keepExistingConfig ? resetMapConfigUpdater(state) : state;\n  for (const merger of state.mergers) {\n    if (isValidMerger(merger) && config.visState[merger.prop]) {\n      mergedState = merger.merge(mergedState, config.visState[merger.prop], true);\n    }\n  }\n\n  return mergedState;\n};\n\n/**\n * Trigger layer hover event with hovered object\n * @memberof visStateUpdaters\n * @public\n */\nexport const layerHoverUpdater = (\n  state: VisState,\n  action: VisStateActions.OnLayerHoverUpdaterAction\n): VisState => ({\n  ...state,\n  hoverInfo: {\n    // deck.gl info is mutable\n    ...action.info\n  }\n});\n\n/* eslint-enable max-statements */\n\n/**\n * Update `interactionConfig`\n * @memberof visStateUpdaters\n * @public\n */\nexport function interactionConfigChangeUpdater(\n  state: VisState,\n  action: VisStateActions.InteractionConfigChangeUpdaterAction\n): VisState {\n  const {config} = action;\n\n  const interactionConfig = {\n    ...state.interactionConfig,\n    ...{[config.id]: config}\n  };\n\n  // Don't enable tooltip and brush at the same time\n  // but coordinates can be shown at all time\n  const contradict = ['brush', 'tooltip'];\n\n  if (\n    contradict.includes(config.id) &&\n    config.enabled &&\n    !state.interactionConfig[config.id].enabled\n  ) {\n    // only enable one interaction at a time\n    contradict.forEach(k => {\n      if (k !== config.id) {\n        interactionConfig[k] = {...interactionConfig[k], enabled: false};\n      }\n    });\n  }\n\n  const newState = {\n    ...state,\n    interactionConfig\n  };\n\n  if (config.id === 'geocoder' && !config.enabled) {\n    return removeDatasetUpdater(newState, {dataId: 'geocoder_dataset'});\n  }\n\n  return newState;\n}\n\n/**\n * Trigger layer click event with clicked object\n * @memberof visStateUpdaters\n * @public\n */\nexport const layerClickUpdater = (\n  state: VisState,\n  action: VisStateActions.OnLayerClickUpdaterAction\n): VisState => ({\n  ...state,\n  mousePos: state.interactionConfig.coordinate.enabled\n    ? {\n        ...state.mousePos,\n        pinned: state.mousePos.pinned ? null : cloneDeep(state.mousePos)\n      }\n    : state.mousePos,\n  clicked: action.info && action.info.picked ? action.info : null\n});\n\n/**\n * Trigger map click event, unselect clicked object\n * @memberof visStateUpdaters\n * @public\n */\nexport const mapClickUpdater = (\n  state: VisState,\n  action: VisStateActions.OnMapClickUpdaterAction\n): VisState => {\n  return {\n    ...state,\n    clicked: null\n  };\n};\n\n/**\n * Trigger map move event\n * @memberof visStateUpdaters\n * @public\n */\nexport const mouseMoveUpdater = (\n  state: VisState,\n  {evt}: VisStateActions.OnMouseMoveUpdaterAction\n): VisState => {\n  if (Object.values(state.interactionConfig).some(config => config.enabled)) {\n    return {\n      ...state,\n      mousePos: {\n        ...state.mousePos,\n        ...(Array.isArray(evt.point) ? {mousePosition: [...evt.point]} : {}),\n        ...(Array.isArray(evt.lngLat) ? {coordinate: [...evt.lngLat]} : {})\n      }\n    };\n  }\n\n  return state;\n};\n/**\n * Toggle visibility of a layer for a split map\n * @memberof visStateUpdaters\n * @public\n */\nexport const toggleSplitMapUpdater = (\n  state: VisState,\n  action: MapStateActions.ToggleSplitMapUpdaterAction\n): VisState =>\n  state.splitMaps && state.splitMaps.length === 0\n    ? {\n        ...state,\n        // maybe we should use an array to store state for a single map as well\n        // if current maps length is equal to 0 it means that we are about to split the view\n        splitMaps: computeSplitMapLayers(state.layers)\n      }\n    : closeSpecificMapAtIndex(state, action);\n\n/**\n * Toggle visibility of a layer in a split map\n * @memberof visStateUpdaters\n * @public\n */\nexport const toggleLayerForMapUpdater = (\n  state: VisState,\n  {mapIndex, layerId}: VisStateActions.ToggleLayerForMapUpdaterAction\n): VisState => {\n  const {splitMaps} = state;\n\n  return {\n    ...state,\n    splitMaps: splitMaps.map((sm, i) =>\n      i === mapIndex\n        ? {\n            ...splitMaps[i],\n            layers: {\n              ...splitMaps[i].layers,\n              // if layerId not in layers, set it to visible\n              [layerId]: !splitMaps[i].layers[layerId]\n            }\n          }\n        : sm\n    )\n  };\n};\n\n/**\n * Add new dataset to `visState`, with option to load a map config along with the datasets\n * @memberof visStateUpdaters\n * @public\n */\n/* eslint-disable max-statements */\n// eslint-disable-next-line complexity\nexport const updateVisDataUpdater = (\n  state: VisState,\n  action: VisStateActions.UpdateVisDataUpdaterAction\n): VisState => {\n  // datasets can be a single data entries or an array of multiple data entries\n  const {config, options} = action;\n  const datasets = toArray(action.datasets);\n\n  const newDataEntries = datasets.reduce(\n    (accu, {info = {}, ...rest} = {}) => ({\n      ...accu,\n      ...(createNewDataEntry({info, ...rest}, state.datasets) || {})\n    }),\n    {}\n  );\n\n  const dataEmpty = Object.keys(newDataEntries).length < 1;\n\n  // apply config if passed from action\n  const previousState = config\n    ? receiveMapConfigUpdater(state, {\n        payload: {config, options}\n      })\n    : state;\n\n  let mergedState = {\n    ...previousState,\n    datasets: {\n      ...previousState.datasets,\n      ...newDataEntries\n    }\n  };\n\n  // merge state with config to be merged\n  for (const merger of mergedState.mergers) {\n    if (isValidMerger(merger) && merger.toMergeProp && mergedState[merger.toMergeProp]) {\n      const toMerge = mergedState[merger.toMergeProp];\n      mergedState[merger.toMergeProp] = INITIAL_VIS_STATE[merger.toMergeProp];\n      mergedState = merger.merge(mergedState, toMerge);\n    }\n  }\n\n  let newLayers = !dataEmpty\n    ? mergedState.layers.filter(l => l.config.dataId && l.config.dataId in newDataEntries)\n    : [];\n\n  if (!newLayers.length && (options || {}).autoCreateLayers !== false) {\n    // no layer merged, find defaults\n    const result = addDefaultLayers(mergedState, newDataEntries);\n    mergedState = result.state;\n    newLayers = result.newLayers;\n  }\n\n  if (mergedState.splitMaps.length) {\n    // if map is split, add new layers to splitMaps\n    newLayers = mergedState.layers.filter(\n      l => l.config.dataId && l.config.dataId in newDataEntries\n    );\n    mergedState = {\n      ...mergedState,\n      splitMaps: addNewLayersToSplitMap(mergedState.splitMaps, newLayers)\n    };\n  }\n\n  // if no tooltips merged add default tooltips\n  Object.keys(newDataEntries).forEach(dataId => {\n    const tooltipFields = mergedState.interactionConfig.tooltip.config.fieldsToShow[dataId];\n    if (!Array.isArray(tooltipFields) || !tooltipFields.length) {\n      mergedState = addDefaultTooltips(mergedState, newDataEntries[dataId]);\n    }\n  });\n\n  let updatedState = updateAllLayerDomainData(\n    mergedState,\n    dataEmpty ? Object.keys(mergedState.datasets) : Object.keys(newDataEntries),\n    undefined\n  );\n\n  // register layer animation domain,\n  // need to be called after layer data is calculated\n  updatedState = updateAnimationDomain(updatedState);\n\n  return updatedState;\n};\n/* eslint-enable max-statements */\n\n/**\n * Rename an existing dataset in `visState`\n * @memberof visStateUpdaters\n * @public\n */\nexport function renameDatasetUpdater(\n  state: VisState,\n  action: VisStateActions.RenameDatasetUpdaterAction\n): VisState {\n  const {dataId, label} = action;\n  const {datasets} = state;\n  const existing = datasets[dataId];\n\n  if (existing) {\n    const newDataset = copyTableAndUpdate(existing, {label});\n    return {\n      ...state,\n      datasets: {\n        ...datasets,\n        [dataId]: newDataset\n      }\n    };\n  }\n\n  // No-op if the dataset doesn't exist\n  return state;\n}\n\n/**\n * When a user clicks on the specific map closing icon\n * the application will close the selected map\n * and will merge the remaining one with the global state\n * TODO: i think in the future this action should be called merge map layers with global settings\n * @param {Object} state `visState`\n * @param {Object} action action\n * @returns {Object} nextState\n */\nexport function closeSpecificMapAtIndex<S extends VisState>(\n  state: S,\n  action: MapStateActions.ToggleSplitMapUpdaterAction\n): S {\n  // retrieve layers meta data from the remaining map that we need to keep\n  const indexToRetrieve = 1 - action.payload;\n  const mapLayers = state.splitMaps[indexToRetrieve]?.layers;\n  const {layers} = state;\n\n  // update layer visibility\n  const newLayers = layers.map(layer =>\n    mapLayers && !mapLayers[layer.id] && layer.config.isVisible\n      ? layer.updateLayerConfig({\n          // if layer.id is not in mapLayers, it should be inVisible\n          isVisible: false\n        })\n      : layer\n  );\n\n  // delete map\n  return {\n    ...state,\n    layers: newLayers,\n    splitMaps: []\n  };\n}\n\n/**\n * Trigger file loading dispatch `addDataToMap` if succeed, or `loadFilesErr` if failed\n * @memberof visStateUpdaters\n * @public\n */\nexport const loadFilesUpdater = (\n  state: VisState,\n  action: VisStateActions.LoadFilesUpdaterAction\n): VisState => {\n  const {files, onFinish = loadFilesSuccess} = action;\n  if (!files.length) {\n    return state;\n  }\n\n  const fileLoadingProgress = Array.from(files).reduce(\n    (accu, f, i) => merge_(initialFileLoadingProgress(f, i))(accu),\n    {}\n  );\n\n  const fileLoading = {\n    fileCache: [],\n    filesToLoad: files,\n    onFinish\n  };\n\n  const nextState = merge_({fileLoadingProgress, fileLoading})(state);\n\n  return loadNextFileUpdater(nextState);\n};\n\n/**\n * Sucessfully loaded one file, move on to the next one\n * @memberof visStateUpdaters\n * @public\n */\nexport function loadFileStepSuccessUpdater(\n  state: VisState,\n  action: VisStateActions.LoadFileStepSuccessAction\n): VisState {\n  if (!state.fileLoading) {\n    return state;\n  }\n  const {fileName, fileCache} = action;\n  const {filesToLoad, onFinish} = state.fileLoading;\n  const stateWithProgress = updateFileLoadingProgressUpdater(state, {\n    fileName,\n    progress: {percent: 1, message: 'Done'}\n  });\n\n  // save processed file to fileCache\n  const stateWithCache = pick_('fileLoading')(merge_({fileCache}))(stateWithProgress);\n\n  return withTask(\n    stateWithCache,\n    DELAY_TASK(200).map(filesToLoad.length ? loadNextFile : () => onFinish(fileCache))\n  );\n}\n\n// withTask<T>(state: T, task: any): T\n\n/**\n *\n * @memberof visStateUpdaters\n * @public\n */\nexport function loadNextFileUpdater(state: VisState): VisState {\n  if (!state.fileLoading) {\n    return state;\n  }\n  const {filesToLoad} = state.fileLoading;\n  const [file, ...remainingFilesToLoad] = filesToLoad;\n\n  // save filesToLoad to state\n  const nextState = pick_('fileLoading')(merge_({filesToLoad: remainingFilesToLoad}))(state);\n\n  const stateWithProgress = updateFileLoadingProgressUpdater(nextState, {\n    fileName: file.name,\n    progress: {percent: 0, message: 'loading...'}\n  });\n\n  const {loaders, loadOptions} = state;\n  return withTask(\n    stateWithProgress,\n    makeLoadFileTask(\n      file,\n      nextState.fileLoading && nextState.fileLoading.fileCache,\n      loaders,\n      loadOptions\n    )\n  );\n}\n\nexport function makeLoadFileTask(file, fileCache, loaders: Loader[] = [], loadOptions = {}) {\n  return LOAD_FILE_TASK({file, fileCache, loaders, loadOptions}).bimap(\n    // prettier ignore\n    // success\n    gen =>\n      nextFileBatch({\n        gen,\n        fileName: file.name,\n        onFinish: result =>\n          processFileContent({\n            content: result,\n            fileCache\n          })\n      }),\n\n    // error\n    err => loadFilesErr(file.name, err)\n  );\n}\n\n/**\n *\n * @memberof visStateUpdaters\n * @public\n */\nexport function processFileContentUpdater(\n  state: VisState,\n  action: VisStateActions.ProcessFileContentUpdaterAction\n): VisState {\n  const {content, fileCache} = action.payload;\n\n  const stateWithProgress = updateFileLoadingProgressUpdater(state, {\n    fileName: content.fileName,\n    progress: {percent: 1, message: 'processing...'}\n  });\n\n  return withTask(\n    stateWithProgress,\n    PROCESS_FILE_DATA({content, fileCache}).bimap(\n      result => loadFileStepSuccess({fileName: content.fileName, fileCache: result}),\n      err => loadFilesErr(content.fileName, err)\n    )\n  );\n}\n\nexport function parseProgress(prevProgress = {}, progress) {\n  // This happens when receiving query metadata or other cases we don't\n  // have an update for the user.\n  if (!progress || !progress.percent) {\n    return {};\n  }\n\n  return {\n    percent: progress.percent\n  };\n}\n\n/**\n * gets called with payload = AsyncGenerator<???>\n * @memberof visStateUpdaters\n * @public\n */\nexport const nextFileBatchUpdater = (\n  state: VisState,\n  {\n    payload: {gen, fileName, progress, accumulated, onFinish}\n  }: VisStateActions.NextFileBatchUpdaterAction\n): VisState => {\n  const stateWithProgress = updateFileLoadingProgressUpdater(state, {\n    fileName,\n    progress: parseProgress(state.fileLoadingProgress[fileName], progress)\n  });\n  return withTask(\n    stateWithProgress,\n    UNWRAP_TASK(gen.next()).bimap(\n      ({value, done}) => {\n        return done\n          ? onFinish(accumulated)\n          : nextFileBatch({\n              gen,\n              fileName,\n              progress: value.progress,\n              accumulated: value,\n              onFinish\n            });\n      },\n      err => loadFilesErr(fileName, err)\n    )\n  );\n};\n\n/**\n * Trigger loading file error\n * @memberof visStateUpdaters\n * @public\n */\nexport const loadFilesErrUpdater = (\n  state: VisState,\n  {error, fileName}: VisStateActions.LoadFilesErrUpdaterAction\n): VisState => {\n  // update ui with error message\n  Console.warn(error);\n  if (!state.fileLoading) {\n    return state;\n  }\n  const {filesToLoad, onFinish, fileCache} = state.fileLoading;\n\n  const nextState = updateFileLoadingProgressUpdater(state, {\n    fileName,\n    progress: {error}\n  });\n\n  // kick off next file or finish\n  return withTask(\n    nextState,\n    DELAY_TASK(200).map(filesToLoad.length ? loadNextFile : () => onFinish(fileCache))\n  );\n};\n\n/**\n * When select dataset for export, apply cpu filter to selected dataset\n * @memberof visStateUpdaters\n * @public\n */\nexport const applyCPUFilterUpdater = (\n  state: VisState,\n  {dataId}: VisStateActions.ApplyCPUFilterUpdaterAction\n): VisState => {\n  // apply cpuFilter\n  const dataIds = toArray(dataId);\n\n  return dataIds.reduce((accu, id) => filterDatasetCPU(accu, id), state);\n};\n\n/**\n * User input to update the info of the map\n * @memberof visStateUpdaters\n * @public\n */\nexport const setMapInfoUpdater = (\n  state: VisState,\n  action: VisStateActions.SetMapInfoUpdaterAction\n): VisState => ({\n  ...state,\n  mapInfo: {\n    ...state.mapInfo,\n    ...action.info\n  }\n});\n/**\n * Helper function to update All layer domain and layer data of state\n */\nexport function addDefaultLayers(\n  state: VisState,\n  datasets: Datasets\n): {state: VisState; newLayers: Layer[]} {\n  const empty: Layer[] = [];\n  const defaultLayers = Object.values(datasets).reduce((accu: Layer[], dataset) => {\n    const foundLayers = findDefaultLayer(dataset, state.layerClasses);\n    return foundLayers && foundLayers.length ? accu.concat(foundLayers) : accu;\n  }, empty);\n\n  return {\n    state: {\n      ...state,\n      layers: [...state.layers, ...defaultLayers],\n      layerOrder: [\n        // put new layers on top of old ones\n        ...defaultLayers.map((_, i) => state.layers.length + i),\n        ...state.layerOrder\n      ]\n    },\n    newLayers: defaultLayers\n  };\n}\n\n/**\n * helper function to find default tooltips\n * @param {Object} state\n * @param {Object} dataset\n * @returns {Object} nextState\n */\nexport function addDefaultTooltips(state, dataset) {\n  const tooltipFields = findFieldsToShow({\n    ...dataset,\n    maxDefaultTooltips: state.maxDefaultTooltips\n  });\n  const merged = {\n    ...state.interactionConfig.tooltip.config.fieldsToShow,\n    ...tooltipFields\n  };\n\n  return set(['interactionConfig', 'tooltip', 'config', 'fieldsToShow'], merged, state);\n}\n\nexport function initialFileLoadingProgress(file, index) {\n  const fileName = file.name || `Untitled File ${index}`;\n  return {\n    [fileName]: {\n      // percent of current file\n      percent: 0,\n      message: '',\n      fileName,\n      error: null\n    }\n  };\n}\n\nexport function updateFileLoadingProgressUpdater(state, {fileName, progress}) {\n  // @ts-expect-error\n  return pick_('fileLoadingProgress')(pick_(fileName)(merge_(progress)))(state);\n}\n/**\n * Helper function to update layer domains for an array of datasets\n */\nexport function updateAllLayerDomainData(\n  state: VisState,\n  dataId: string | string[],\n  updatedFilter?: Filter\n): VisState {\n  const dataIds = typeof dataId === 'string' ? [dataId] : dataId;\n  const newLayers: Layer[] = [];\n  const newLayerData: any[] = [];\n\n  state.layers.forEach((oldLayer, i) => {\n    if (oldLayer.config.dataId && dataIds.includes(oldLayer.config.dataId)) {\n      // No need to recalculate layer domain if filter has fixed domain\n      const newLayer =\n        updatedFilter && updatedFilter.fixedDomain\n          ? oldLayer\n          : oldLayer.updateLayerDomain(state.datasets, updatedFilter);\n\n      const {layerData, layer} = calculateLayerData(newLayer, state, state.layerData[i]);\n\n      newLayers.push(layer);\n      newLayerData.push(layerData);\n    } else {\n      newLayers.push(oldLayer);\n      newLayerData.push(state.layerData[i]);\n    }\n  });\n\n  const newState = {\n    ...state,\n    layers: newLayers,\n    layerData: newLayerData\n  };\n\n  return newState;\n}\n\nexport function updateAnimationDomain<S extends VisState>(state: S): S {\n  // merge all animatable layer domain and update global config\n  const animatableLayers = state.layers.filter(\n    l =>\n      l.config.isVisible &&\n      l.config.animation &&\n      l.config.animation.enabled &&\n      // @ts-expect-error trip-layer-only\n      Array.isArray(l.animationDomain)\n  );\n\n  if (!animatableLayers.length) {\n    return {\n      ...state,\n      animationConfig: {\n        ...state.animationConfig,\n        domain: null,\n        defaultTimeFormat: null\n      }\n    };\n  }\n\n  const mergedDomain: [number, number] = animatableLayers.reduce(\n    (accu, layer) => [\n      // @ts-expect-error trip-layer-only\n      Math.min(accu[0], layer.animationDomain[0]),\n      // @ts-expect-error trip-layer-only\n      Math.max(accu[1], layer.animationDomain[1])\n    ],\n    [Number(Infinity), -Infinity]\n  );\n  const defaultTimeFormat = getTimeWidgetTitleFormatter(mergedDomain);\n\n  return {\n    ...state,\n    animationConfig: {\n      ...state.animationConfig,\n      currentTime: isInRange(state.animationConfig.currentTime, mergedDomain)\n        ? state.animationConfig.currentTime\n        : mergedDomain[0],\n      domain: mergedDomain,\n      defaultTimeFormat\n    }\n  };\n}\n\n/**\n * Update the status of the editor\n * @memberof visStateUpdaters\n */\nexport const setEditorModeUpdater = (\n  state: VisState,\n  {mode}: VisStateActions.SetEditorModeUpdaterAction\n): VisState => ({\n  ...state,\n  editor: {\n    ...state.editor,\n    mode,\n    selectedFeature: null\n  }\n});\n\n// const featureToFilterValue = (feature) => ({...feature, id: feature.id});\n/**\n * Update editor features\n * @memberof visStateUpdaters\n */\nexport function setFeaturesUpdater(\n  state: VisState,\n  {features = []}: VisStateActions.SetFeaturesUpdaterAction\n): VisState {\n  const lastFeature = features.length && features[features.length - 1];\n\n  const newState = {\n    ...state,\n    editor: {\n      ...state.editor,\n      // only save none filter features to editor\n      features: features.filter(f => !getFilterIdInFeature(f)),\n      mode: lastFeature && lastFeature.properties.isClosed ? EDITOR_MODES.EDIT : state.editor.mode\n    }\n  };\n\n  // Retrieve existing feature\n  const {selectedFeature} = state.editor;\n\n  // If no feature is selected we can simply return since no operations\n  if (!selectedFeature) {\n    return newState;\n  }\n\n  // TODO: check if the feature has changed\n  const feature = features.find(f => f.id === selectedFeature.id);\n\n  // if feature is part of a filter\n  const filterId = feature && getFilterIdInFeature(feature);\n  if (filterId && feature) {\n    const featureValue = featureToFilterValue(feature, filterId);\n    const filterIdx = state.filters.findIndex(fil => fil.id === filterId);\n    // @ts-ignore\n    return setFilterUpdater(newState, {\n      idx: filterIdx,\n      prop: 'value',\n      value: featureValue\n    });\n  }\n\n  return newState;\n}\n\n/**\n * Set the current selected feature\n * @memberof uiStateUpdaters\n */\nexport const setSelectedFeatureUpdater = (\n  state: VisState,\n  {feature}: VisStateActions.SetSelectedFeatureUpdaterAction\n): VisState => ({\n  ...state,\n  editor: {\n    ...state.editor,\n    selectedFeature: feature\n  }\n});\n\n/**\n * Delete existing feature from filters\n * @memberof visStateUpdaters\n */\nexport function deleteFeatureUpdater(\n  state: VisState,\n  {feature}: VisStateActions.DeleteFeatureUpdaterAction\n): VisState {\n  if (!feature) {\n    return state;\n  }\n\n  const newState = {\n    ...state,\n    editor: {\n      ...state.editor,\n      selectedFeature: null\n    }\n  };\n\n  if (getFilterIdInFeature(feature)) {\n    const filterIdx = newState.filters.findIndex(f => f.id === getFilterIdInFeature(feature));\n\n    return filterIdx > -1 ? removeFilterUpdater(newState, {idx: filterIdx}) : newState;\n  }\n\n  // modify editor object\n  const newEditor = {\n    ...state.editor,\n    features: state.editor.features.filter(f => f.id !== feature.id),\n    selectedFeature: null\n  };\n\n  return {\n    ...state,\n    editor: newEditor\n  };\n}\n\n/**\n * Toggle feature as layer filter\n * @memberof visStateUpdaters\n */\nexport function setPolygonFilterLayerUpdater(\n  state: VisState,\n  payload: VisStateActions.SetPolygonFilterLayerUpdaterAction\n): VisState {\n  const {layer, feature} = payload;\n  const filterId = getFilterIdInFeature(feature);\n\n  // let newFilter = null;\n  let filterIdx;\n  let newLayerId = [layer.id];\n  let newState = state;\n  // If polygon filter already exists, we need to find out if the current layer is already included\n  if (filterId) {\n    filterIdx = state.filters.findIndex(f => f.id === filterId);\n\n    if (!state.filters[filterIdx]) {\n      // what if filter doesn't exist?... not possible.\n      // because features in the editor is passed in from filters and editors.\n      // but we will move this feature back to editor just in case\n      const noneFilterFeature = {\n        ...feature,\n        properties: {\n          ...feature.properties,\n          filterId: null\n        }\n      };\n\n      return {\n        ...state,\n        editor: {\n          ...state.editor,\n          features: [...state.editor.features, noneFilterFeature],\n          selectedFeature: noneFilterFeature\n        }\n      };\n    }\n    const filter = state.filters[filterIdx];\n    const {layerId = []} = filter;\n    const isLayerIncluded = layerId.includes(layer.id);\n\n    newLayerId = isLayerIncluded\n      ? // if layer is included, remove it\n        layerId.filter(l => l !== layer.id)\n      : [...layerId, layer.id];\n  } else {\n    // if we haven't create the polygon filter, create it\n    const newFilter = generatePolygonFilter([], feature);\n    filterIdx = state.filters.length;\n\n    // add feature, remove feature from eidtor\n    newState = {\n      ...state,\n      filters: [...state.filters, newFilter],\n      editor: {\n        ...state.editor,\n        features: state.editor.features.filter(f => f.id !== feature.id),\n        selectedFeature: newFilter.value\n      }\n    };\n  }\n\n  return setFilterUpdater(newState, {\n    idx: filterIdx,\n    prop: 'layerId',\n    value: newLayerId\n  });\n}\n\n/**\n * @memberof visStateUpdaters\n * @public\n */\nexport function sortTableColumnUpdater(\n  state: VisState,\n  {dataId, column, mode}: VisStateActions.SortTableColumnUpdaterAction\n): VisState {\n  const dataset = state.datasets[dataId];\n  if (!dataset) {\n    return state;\n  }\n  let sortMode = mode;\n  if (!sortMode) {\n    const currentMode = get(dataset, ['sortColumn', column]);\n    // @ts-ignore - should be fixable in a TS file\n    sortMode = currentMode\n      ? Object.keys(SORT_ORDER).find(m => m !== currentMode)\n      : SORT_ORDER.ASCENDING;\n  }\n\n  const sorted = sortDatasetByColumn(dataset, column, sortMode);\n  return set(['datasets', dataId], sorted, state);\n}\n\n/**\n * @memberof visStateUpdaters\n * @public\n */\nexport function pinTableColumnUpdater(\n  state: VisState,\n  {dataId, column}: VisStateActions.PinTableColumnUpdaterAction\n): VisState {\n  const dataset = state.datasets[dataId];\n  if (!dataset) {\n    return state;\n  }\n  const newDataset = pinTableColumns(dataset, column);\n\n  return set(['datasets', dataId], newDataset, state);\n}\n\n/**\n * Copy column content as strings\n * @memberof visStateUpdaters\n * @public\n */\nexport function copyTableColumnUpdater(\n  state: VisState,\n  {dataId, column}: VisStateActions.CopyTableColumnUpdaterAction\n): VisState {\n  const dataset = state.datasets[dataId];\n  if (!dataset) {\n    return state;\n  }\n  const fieldIdx = dataset.fields.findIndex(f => f.name === column);\n  if (fieldIdx < 0) {\n    return state;\n  }\n  const {type} = dataset.fields[fieldIdx];\n  const text = dataset.dataContainer\n    .map(row => parseFieldValue(row.valueAt(fieldIdx), type), true)\n    .join('\\n');\n\n  copy(text);\n\n  return state;\n}\n\n/**\n * Update editor\n */\nexport function toggleEditorVisibilityUpdater(\n  state: VisState,\n  action: VisStateActions.ToggleEditorVisibilityUpdaterAction\n): VisState {\n  return {\n    ...state,\n    editor: {\n      ...state.editor,\n      visible: !state.editor.visible\n    }\n  };\n}\n\nexport function setFilterAnimationTimeConfigUpdater(\n  state: VisState,\n  {idx, config}: VisStateActions.SetFilterAnimationTimeConfigAction\n): VisState {\n  const oldFilter = state.filters[idx];\n  if (!oldFilter) {\n    Console.error(`filters.${idx} is undefined`);\n    return state;\n  }\n  if (oldFilter.type !== FILTER_TYPES.timeRange) {\n    Console.error(\n      `setFilterAnimationTimeConfig can only be called to update a time filter. check filter.type === 'timeRange'`\n    );\n    return state;\n  }\n\n  const updates = checkTimeConfigArgs(config);\n\n  return pick_('filters')(swap_(merge_(updates)(oldFilter)))(state);\n}\n\nfunction checkTimeConfigArgs(config) {\n  const allowed = ['timeFormat', 'timezone'];\n  return Object.keys(config).reduce((accu, prop) => {\n    if (!allowed.includes(prop)) {\n      Console.error(\n        `setLayerAnimationTimeConfig takes timeFormat and/or timezone as options, found ${prop}`\n      );\n      return accu;\n    }\n\n    // here we are NOT checking if timezone or timeFormat input is valid\n    accu[prop] = config[prop];\n    return accu;\n  }, {});\n}\n/**\n * Update editor\n */\nexport function setLayerAnimationTimeConfigUpdater(\n  state: VisState,\n  {config}: VisStateActions.SetLayerAnimationTimeConfigAction\n): VisState {\n  if (!config) {\n    return state;\n  }\n  const updates = checkTimeConfigArgs(config);\n  return pick_('animationConfig')(merge_(updates))(state);\n}\n"]}