@carto/kepler.gl 0.0.81 → 0.0.82

package/src/reducers/vis-state-updaters.js

@@ -1,2137 +0,0 @@
-// 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.
-
-import {console as Console} from 'global/window';
-import {disableStackCapturing, withTask} from 'react-palm/tasks';
-import cloneDeep from 'lodash/cloneDeep';
-import uniq from 'lodash/uniq';
-import get from 'lodash/get';
-import xor from 'lodash/xor';
-import copy from 'copy-to-clipboard';
-import {parseFieldValue} from 'utils/data-utils';
-// Tasks
-import {LOAD_FILE_TASK, UNWRAP_TASK, PROCESS_FILE_DATA, DELAY_TASK} from 'tasks/tasks';
-// Actions
-import {
-  loadFilesErr,
-  loadFilesSuccess,
-  loadFileStepSuccess,
-  loadNextFile,
-  nextFileBatch
-} from 'actions/vis-state-actions';
-// Utils
-import {findFieldsToShow, getDefaultInteraction} from 'utils/interaction-utils';
-import {
-  applyFilterFieldName,
-  applyFiltersToDatasets,
-  featureToFilterValue,
-  FILTER_UPDATER_PROPS,
-  filterDatasetCPU,
-  generatePolygonFilter,
-  getDefaultFilter,
-  getDefaultFilterPlotType,
-  getFilterIdInFeature,
-  getFilterPlot,
-  getTimeWidgetTitleFormatter,
-  isInRange,
-  LIMITED_FILTER_EFFECT_PROPS,
-  updateFilterDataId
-} from 'utils/filter-utils';
-import {assignGpuChannel, setFilterGpuMode} from 'utils/gpu-filter-utils';
-import {createNewDataEntry} from 'utils/dataset-utils';
-import {sortDatasetByColumn} from 'utils/table-utils/kepler-table';
-import {set, toArray, arrayInsert, generateHashId} from 'utils/utils';
-
-import {calculateLayerData, findDefaultLayer} from 'utils/layer-utils';
-
-import {
-  isValidMerger,
-  VIS_STATE_MERGERS,
-  validateLayerWithData,
-  createLayerFromConfig,
-  serializeLayer
-} from './vis-state-merger';
-
-import {
-  addNewLayersToSplitMap,
-  computeSplitMapLayers,
-  removeLayerFromSplitMaps
-} from 'utils/split-map-utils';
-
-import {Layer, LayerClasses, LAYER_ID_LENGTH} from 'layers';
-import {DEFAULT_TEXT_LABEL, DEFAULT_SECONDARY_TEXT_LABEL} from 'layers/layer-factory';
-import {EDITOR_MODES, SORT_ORDER, FILTER_TYPES} from 'constants/default-settings';
-import {pick_, merge_, swap_} from './composer-helpers';
-import {processFileContent} from 'actions/vis-state-actions';
-
-import KeplerGLSchema from 'schemas';
-
-// type imports
-/** @typedef {import('./vis-state-updaters').Field} Field */
-/** @typedef {import('./vis-state-updaters').Filter} Filter */
-/** @typedef {import('./vis-state-updaters').KeplerTable} KeplerTable */
-/** @typedef {import('./vis-state-updaters').VisState} VisState */
-/** @typedef {import('./vis-state-updaters').Datasets} Datasets */
-/** @typedef {import('./vis-state-updaters').AnimationConfig} AnimationConfig */
-/** @typedef {import('./vis-state-updaters').Editor} Editor */
-
-// react-palm
-// disable capture exception for react-palm call to withTask
-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
-const visStateUpdaters = null;
-/* eslint-enable no-unused-vars */
-
-/** @type {AnimationConfig} */
-export const DEFAULT_ANIMATION_CONFIG = {
-  domain: null,
-  currentTime: null,
-  speed: 1,
-  isAnimating: false,
-  timeFormat: null,
-  timezone: null,
-  defaultTimeFormat: null
-};
-
-/** @type {Editor} */
-export const DEFAULT_EDITOR = {
-  mode: EDITOR_MODES.DRAW_POLYGON,
-  features: [],
-  selectedFeature: null,
-  visible: true
-};
-
-/**
- * Default initial `visState`
- * @memberof visStateUpdaters
- * @constant
- * @type {VisState}
- * @public
- */
-export const 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: getDefaultInteraction(),
-  interactionToBeMerged: undefined,
-
-  layerBlending: 'normal',
-  hoverInfo: undefined,
-  clicked: undefined,
-  mousePos: {},
-
-  // 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: 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: VIS_STATE_MERGERS,
-
-  // kepler schemas
-  schema: KeplerGLSchema
-};
-
-/**
- * Update state with updated layer and layerData
- * @type {typeof import('./vis-state-updaters').updateStateWithLayerAndData}
- *
- */
-export function updateStateWithLayerAndData(state, {layerData, layer, idx}) {
-  return {
-    ...state,
-    layers: state.layers.map((lyr, i) => (i === idx ? layer : lyr)),
-    layerData: layerData
-      ? state.layerData.map((d, i) => (i === idx ? layerData : d))
-      : state.layerData
-  };
-}
-
-export function updateStateOnLayerVisibilityChange(state, layer) {
-  let newState = state;
-  if (state.splitMaps.length) {
-    newState = {
-      ...state,
-      splitMaps: layer.config.isVisible
-        ? addNewLayersToSplitMap(state.splitMaps, layer)
-        : removeLayerFromSplitMaps(state.splitMaps, layer)
-    };
-  }
-
-  if (layer.config.animation.enabled) {
-    newState = updateAnimationDomain(state);
-  }
-
-  return newState;
-}
-
-/**
- * Update layer base config: dataId, label, column, isVisible
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').layerConfigChangeUpdater}
- * @returns nextState
- */
-export function layerConfigChangeUpdater(state, action) {
-  const {oldLayer} = action;
-  const idx = state.layers.findIndex(l => l.id === oldLayer.id);
-  const props = Object.keys(action.newConfig);
-  if (typeof action.newConfig.dataId === 'string') {
-    const {dataId, ...restConfig} = action.newConfig;
-    const stateWithDataId = layerDataIdChangeUpdater(state, {
-      oldLayer,
-      newConfig: {dataId}
-    });
-    const nextLayer = stateWithDataId.layers.find(l => l.id === oldLayer.id);
-    return nextLayer && Object.keys(restConfig).length
-      ? layerConfigChangeUpdater(stateWithDataId, {oldLayer: nextLayer, newConfig: restConfig})
-      : stateWithDataId;
-  }
-
-  let newLayer = oldLayer.updateLayerConfig(action.newConfig);
-
-  let layerData;
-
-  // let newLayer;
-  if (newLayer.shouldCalculateLayerData(props)) {
-    const oldLayerData = state.layerData[idx];
-    const updateLayerDataResult = calculateLayerData(newLayer, state, oldLayerData);
-
-    layerData = updateLayerDataResult.layerData;
-    newLayer = updateLayerDataResult.layer;
-  }
-
-  let newState = state;
-  if ('isVisible' in action.newConfig) {
-    newState = updateStateOnLayerVisibilityChange(state, newLayer);
-  }
-
-  return updateStateWithLayerAndData(newState, {
-    layer: newLayer,
-    layerData,
-    idx
-  });
-}
-
-function addOrRemoveTextLabels(newFields, textLabel) {
-  let newTextLabel = textLabel.slice();
-
-  const currentFields = textLabel.map(tl => tl.field && tl.field.name).filter(d => d);
-
-  const addFields = newFields.filter(f => !currentFields.includes(f.name));
-  const deleteFields = currentFields.filter(f => !newFields.find(fd => fd.name === f));
-
-  // delete
-  newTextLabel = newTextLabel.filter(tl => tl.field && !deleteFields.includes(tl.field.name));
-
-  // add
-  newTextLabel = newTextLabel.filter(tl => tl.field);
-  const defaultLabel = newTextLabel.length ? DEFAULT_SECONDARY_TEXT_LABEL : DEFAULT_TEXT_LABEL;
-  newTextLabel = [...newTextLabel, ...addFields.map(af => ({...defaultLabel, field: af}))];
-
-  // limit to 2 labels (overwrite 2nd label with 3rd)
-  if (newTextLabel.length > 2) {
-    newTextLabel = [newTextLabel[0], newTextLabel[2]];
-  }
-
-  // default
-  newTextLabel = !newTextLabel.length ? [DEFAULT_TEXT_LABEL] : newTextLabel;
-
-  return newTextLabel;
-}
-
-function updateTextLabelPropAndValue(idx, prop, value, textLabel) {
-  if (!textLabel[idx].hasOwnProperty(prop)) {
-    return textLabel;
-  }
-
-  let newTextLabel = textLabel.slice();
-
-  if (prop && (value || textLabel.length === 1)) {
-    newTextLabel = textLabel.map((tl, i) => (i === idx ? {...tl, [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
- * @type {typeof import('./vis-state-updaters').layerTextLabelChangeUpdater}
- * @returns nextState
- */
-export function layerTextLabelChangeUpdater(state, action) {
-  const {oldLayer, idx, prop, value} = action;
-  const {textLabel} = oldLayer.config;
-
-  let newTextLabel = textLabel.slice();
-  if (!textLabel[idx] && idx === textLabel.length) {
-    // if idx is set to length, add empty text label
-    newTextLabel = [...textLabel, idx === 0 ? DEFAULT_TEXT_LABEL : DEFAULT_SECONDARY_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,
-    newConfig: {textLabel: newTextLabel}
-  });
-}
-
-function validateExistingLayerWithData(dataset, layerClasses, layer) {
-  const loadedLayer = serializeLayer(layer);
-  return validateLayerWithData(dataset, loadedLayer, layerClasses, {
-    allowEmptyColumn: true
-  });
-}
-
-/**
- * Update layer config dataId
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').layerDataIdChangeUpdater}
- * @returns nextState
- */
-export function layerDataIdChangeUpdater(state, action) {
-  const {oldLayer, newConfig} = action;
-  const {dataId} = newConfig;
-
-  if (!oldLayer || !state.datasets[dataId]) {
-    return state;
-  }
-  const idx = state.layers.findIndex(l => l.id === oldLayer.id);
-
-  let newLayer = oldLayer.updateLayerConfig({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()) {
-    const validated = validateExistingLayerWithData(
-      state.datasets[dataId],
-      state.layerClasses,
-      newLayer
-    );
-    // if cant validate it with data create a new one
-    if (!validated) {
-      newLayer = new state.layerClasses[oldLayer.type]({dataId, id: oldLayer.id});
-    } else {
-      newLayer = validated;
-    }
-  }
-
-  newLayer = newLayer.updateLayerConfig({
-    isVisible: oldLayer.config.isVisible,
-    isConfigActive: true
-  });
-
-  newLayer.updateLayerDomain(state.datasets);
-  const {layerData, layer} = calculateLayerData(newLayer, state, undefined);
-
-  return updateStateWithLayerAndData(state, {layerData, layer, idx});
-}
-
-/**
- * Update layer type. Previews layer config will be copied if applicable.
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').layerTypeChangeUpdater}
- * @public
- */
-export function layerTypeChangeUpdater(state, action) {
-  const {oldLayer, newType} = action;
-  if (!oldLayer) {
-    return state;
-  }
-  const oldId = oldLayer.id;
-  const idx = state.layers.findIndex(l => l.id === oldId);
-
-  if (!state.layerClasses[newType]) {
-    Console.error(`${newType} is not a valid layer type`);
-    return state;
-  }
-
-  // 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
-  const newLayer = new state.layerClasses[newType]();
-
-  newLayer.assignConfigToLayer(oldLayer.config, oldLayer.visConfigSettings);
-
-  newLayer.updateLayerDomain(state.datasets);
-  const {layerData, layer} = calculateLayerData(newLayer, state);
-  let newState = updateStateWithLayerAndData(state, {layerData, layer, idx});
-
-  if (layer.config.animation.enabled || oldLayer.config.animation.enabled) {
-    newState = updateAnimationDomain(newState);
-  }
-
-  // update splitMap layer id
-  if (state.splitMaps.length) {
-    newState = {
-      ...newState,
-      splitMaps: newState.splitMaps.map(settings => {
-        const {[oldId]: oldLayerMap, ...otherLayers} = settings.layers;
-        return oldId in settings.layers
-          ? {
-              ...settings,
-              layers: {
-                ...otherLayers,
-                [layer.id]: oldLayerMap
-              }
-            }
-          : settings;
-      })
-    };
-  }
-
-  return newState;
-}
-
-/**
- * Update layer visual channel
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').layerVisualChannelChangeUpdater}
- * @returns {Object} nextState
- * @public
- */
-export function layerVisualChannelChangeUpdater(state, action) {
-  const {oldLayer, newConfig, channel} = action;
-  if (!oldLayer.config.dataId) {
-    return state;
-  }
-  const dataset = state.datasets[oldLayer.config.dataId];
-
-  const idx = state.layers.findIndex(l => l.id === oldLayer.id);
-  const newLayer = oldLayer.updateLayerConfig(newConfig);
-
-  newLayer.updateLayerVisualChannel(dataset, channel);
-
-  const oldLayerData = state.layerData[idx];
-  const {layerData, layer} = calculateLayerData(newLayer, state, oldLayerData);
-
-  return updateStateWithLayerAndData(state, {layerData, layer, idx});
-}
-
-/**
- * Update layer `visConfig`
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').layerVisConfigChangeUpdater}
- * @public
- */
-export function layerVisConfigChangeUpdater(state, action) {
-  const {oldLayer} = action;
-  const idx = state.layers.findIndex(l => l.id === oldLayer.id);
-  const props = Object.keys(action.newVisConfig);
-  const newVisConfig = {
-    ...oldLayer.config.visConfig,
-    ...action.newVisConfig
-  };
-
-  const newLayer = oldLayer.updateLayerConfig({visConfig: newVisConfig});
-
-  if (newLayer.shouldCalculateLayerData(props)) {
-    const oldLayerData = state.layerData[idx];
-    const {layerData, layer} = calculateLayerData(newLayer, state, oldLayerData);
-    return updateStateWithLayerAndData(state, {layerData, layer, idx});
-  }
-
-  return updateStateWithLayerAndData(state, {layer: newLayer, idx});
-}
-
-/**
- * Update filter property
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').setFilterAnimationTimeUpdater}
- * @public
- */
-export function setFilterAnimationTimeUpdater(state, action) {
-  return setFilterUpdater(state, action);
-}
-
-/**
- * Update filter animation window
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').setFilterAnimationWindowUpdater}
- * @public
- */
-export function setFilterAnimationWindowUpdater(state, {id, animationWindow}) {
-  return {
-    ...state,
-    filters: state.filters.map(f =>
-      f.id === id
-        ? {
-            ...f,
-            animationWindow
-          }
-        : f
-    )
-  };
-}
-/**
- * Update filter property
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').setFilterUpdater}
- * @public
- */
-export function setFilterUpdater(state, action) {
-  const {idx, prop, value, valueIndex = 0} = action;
-  const oldFilter = state.filters[idx];
-
-  if (!oldFilter) {
-    Console.error(`filters.${idx} is undefined`);
-    return state;
-  }
-  let newFilter = set([prop], value, oldFilter);
-  let newState = state;
-
-  const {dataId} = newFilter;
-
-  // Ensuring backward compatibility
-  let datasetIds = 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 FILTER_UPDATER_PROPS.dataId:
-      // if trying to update filter dataId. create an empty new filter
-      newFilter = updateFilterDataId(dataId);
-      break;
-
-    case 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
-      const datasetId = newFilter.dataId[valueIndex];
-      const {filter: updatedFilter, dataset: newDataset} = applyFilterFieldName(
-        newFilter,
-        state.datasets[datasetId],
-        value,
-        valueIndex,
-        {mergeDomain: false}
-      );
-      if (!updatedFilter) {
-        return state;
-      }
-
-      newFilter = updatedFilter;
-
-      if (newFilter.gpu) {
-        newFilter = setFilterGpuMode(newFilter, state.filters);
-        newFilter = assignGpuChannel(newFilter, state.filters);
-      }
-
-      newState = set(['datasets', datasetId], newDataset, state);
-
-      // only filter the current dataset
-      break;
-    case 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
-      const layerIdDifference = xor(newFilter.layerId, oldFilter.layerId);
-
-      const layerDataIds = uniq(
-        layerIdDifference
-          .map(lid =>
-            get(
-              state.layers.find(l => l.id === lid),
-              ['config', 'dataId']
-            )
-          )
-          .filter(d => d)
-      );
-
-      // only filter datasetsIds
-      datasetIds = layerDataIds;
-
-      // Update newFilter dataIds
-      const newDataIds = uniq(
-        newFilter.layerId
-          .map(lid =>
-            get(
-              state.layers.find(l => l.id === lid),
-              ['config', 'dataId']
-            )
-          )
-          .filter(d => d)
-      );
-
-      newFilter = {
-        ...newFilter,
-        dataId: newDataIds
-      };
-
-      break;
-    default:
-      break;
-  }
-
-  const enlargedFilter = state.filters.find(f => f.enlarged);
-
-  if (enlargedFilter && enlargedFilter.id !== newFilter.id) {
-    // there should be only one enlarged filter
-    newFilter.enlarged = false;
-  }
-
-  // save new filters to newState
-  newState = 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
-  const datasetIdsToFilter = LIMITED_FILTER_EFFECT_PROPS[prop]
-    ? [datasetIds[valueIndex]]
-    : datasetIds;
-
-  // filter data
-  const filteredDatasets = applyFiltersToDatasets(
-    datasetIdsToFilter,
-    newState.datasets,
-    newState.filters,
-    newState.layers
-  );
-
-  newState = 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
- * @type {typeof import('./vis-state-updaters').setFilterPlotUpdater}
- * @public
- */
-export const setFilterPlotUpdater = (state, {idx, newProp, valueIndex = 0}) => {
-  let newFilter = {...state.filters[idx], ...newProp};
-  const prop = Object.keys(newProp)[0];
-  if (prop === 'yAxis') {
-    const plotType = getDefaultFilterPlotType(newFilter);
-    // TODO: plot is not supported in multi dataset filter for now
-    if (plotType) {
-      newFilter = {
-        ...newFilter,
-        ...getFilterPlot({...newFilter, plotType}, state.datasets[newFilter.dataId[valueIndex]]),
-        plotType
-      };
-    }
-  }
-
-  return {
-    ...state,
-    filters: state.filters.map((f, i) => (i === idx ? newFilter : f))
-  };
-};
-
-/**
- * Add a new filter
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').addFilterUpdater}
- * @public
- */
-export const addFilterUpdater = (state, action) =>
-  !action.dataId
-    ? state
-    : {
-        ...state,
-        filters: [...state.filters, getDefaultFilter(action.dataId)]
-      };
-
-/**
- * Set layer color palette ui state
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').layerColorUIChangeUpdater}
- */
-export const layerColorUIChangeUpdater = (state, {oldLayer, prop, newConfig}) => {
-  const oldVixConfig = oldLayer.config.visConfig[prop];
-  const newLayer = oldLayer.updateLayerColorUI(prop, newConfig);
-  const newVisConfig = newLayer.config.visConfig[prop];
-  if (oldVixConfig !== newVisConfig) {
-    return layerVisConfigChangeUpdater(state, {
-      oldLayer,
-      newVisConfig: {
-        [prop]: newVisConfig
-      }
-    });
-  }
-  return {
-    ...state,
-    layers: state.layers.map(l => (l.id === oldLayer.id ? newLayer : l))
-  };
-};
-
-/**
- * Start and end filter animation
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').toggleFilterAnimationUpdater}
- * @public
- */
-export const toggleFilterAnimationUpdater = (state, action) => ({
-  ...state,
-  filters: state.filters.map((f, i) => (i === action.idx ? {...f, isAnimating: !f.isAnimating} : f))
-});
-
-/**
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').toggleLayerAnimationUpdater}
- * @public
- */
-export const toggleLayerAnimationUpdater = state => ({
-  ...state,
-  animationConfig: {
-    ...state.animationConfig,
-    isAnimating: !state.animationConfig.isAnimating
-  }
-});
-
-/**
- * Hide and show layer animation control
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').toggleLayerAnimationControlUpdater}
- * @public
- */
-export const toggleLayerAnimationControlUpdater = state => ({
-  ...state,
-  animationConfig: {
-    ...state.animationConfig,
-    hideControl: !state.animationConfig.hideControl
-  }
-});
-
-/**
- * Change filter animation speed
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').updateFilterAnimationSpeedUpdater}
- * @public
- */
-export const updateFilterAnimationSpeedUpdater = (state, action) => ({
-  ...state,
-  filters: state.filters.map((f, i) => (i === action.idx ? {...f, speed: action.speed} : f))
-});
-
-/**
- * Reset animation config current time to a specified value
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').setLayerAnimationTimeUpdater}
- * @public
- *
- */
-export const setLayerAnimationTimeUpdater = (state, {value}) => ({
-  ...state,
-  animationConfig: {
-    ...state.animationConfig,
-    currentTime: value
-  }
-});
-
-/**
- * Update animation speed with the vertical speed slider
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').updateLayerAnimationSpeedUpdater}
- * @public
- *
- */
-export const updateLayerAnimationSpeedUpdater = (state, {speed}) => {
-  return {
-    ...state,
-    animationConfig: {
-      ...state.animationConfig,
-      speed
-    }
-  };
-};
-
-/**
- * Show larger time filter at bottom for time playback (apply to time filter only)
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').enlargeFilterUpdater}
- * @public
- */
-export const enlargeFilterUpdater = (state, action) => {
-  return {
-    ...state,
-    filters: state.filters.map((f, i) =>
-      i === action.idx
-        ? {
-            ...f,
-            enlarged: !f.enlarged
-          }
-        : f
-    )
-  };
-};
-
-/**
- * Toggles filter feature visibility
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').toggleFilterFeatureUpdater}
- */
-export const toggleFilterFeatureUpdater = (state, action) => {
-  const filter = state.filters[action.idx];
-  const isVisible = get(filter, ['value', 'properties', 'isVisible']);
-  const newFilter = {
-    ...filter,
-    value: featureToFilterValue(filter.value, filter.id, {
-      isVisible: !isVisible
-    })
-  };
-
-  return {
-    ...state,
-    filters: Object.assign([...state.filters], {[action.idx]: newFilter})
-  };
-};
-
-/**
- * Remove a filter
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').removeFilterUpdater}
- * @public
- */
-export const removeFilterUpdater = (state, action) => {
-  const {idx} = action;
-  const {dataId, id} = state.filters[idx];
-
-  const newFilters = [
-    ...state.filters.slice(0, idx),
-    ...state.filters.slice(idx + 1, state.filters.length)
-  ];
-
-  const filteredDatasets = applyFiltersToDatasets(dataId, state.datasets, newFilters, state.layers);
-  const newEditor =
-    getFilterIdInFeature(state.editor.selectedFeature) === id
-      ? {
-          ...state.editor,
-          selectedFeature: null
-        }
-      : state.editor;
-
-  let newState = set(['filters'], newFilters, state);
-  newState = set(['datasets'], filteredDatasets, newState);
-  newState = set(['editor'], newEditor, newState);
-
-  return updateAllLayerDomainData(newState, dataId, undefined);
-};
-
-/**
- * Add a new layer
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').addLayerUpdater}
- * @public
- */
-export const addLayerUpdater = (state, action) => {
-  let newLayer;
-  let newLayerData;
-  if (action.config) {
-    newLayer = createLayerFromConfig(state, action.config);
-    if (!newLayer) {
-      Console.warn(
-        'Failed to create layer from config, it usually means the config is not be in correct format',
-        action.config
-      );
-      return state;
-    }
-
-    const result = calculateLayerData(newLayer, state);
-    newLayer = result.layer;
-    newLayerData = result.layerData;
-  } else {
-    // create an empty layer with the first available dataset
-    const defaultDataset = Object.keys(state.datasets)[0];
-    newLayer = new Layer({
-      isVisible: true,
-      isConfigActive: true,
-      dataId: defaultDataset
-    });
-    newLayerData = {};
-  }
-  return {
-    ...state,
-    layers: [...state.layers, newLayer],
-    layerData: [...state.layerData, newLayerData],
-    layerOrder: [...state.layerOrder, state.layerOrder.length],
-    splitMaps: addNewLayersToSplitMap(state.splitMaps, newLayer)
-  };
-};
-
-/**
- * remove layer
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').removeLayerUpdater}
- * @public
- */
-export const removeLayerUpdater = (state, {idx}) => {
-  const {layers, layerData, clicked, hoverInfo} = state;
-  const layerToRemove = state.layers[idx];
-  const newMaps = removeLayerFromSplitMaps(state.splitMaps, layerToRemove);
-
-  const newState = {
-    ...state,
-    layers: [...layers.slice(0, idx), ...layers.slice(idx + 1, layers.length)],
-    layerData: [...layerData.slice(0, idx), ...layerData.slice(idx + 1, layerData.length)],
-    layerOrder: state.layerOrder.filter(i => i !== idx).map(pid => (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
- * @type {typeof import('./vis-state-updaters').duplicateLayerUpdater}
- * @public
- */
-export const duplicateLayerUpdater = (state, {idx}) => {
-  const {layers} = state;
-  const original = state.layers[idx];
-  const originalLayerOrderIdx = state.layerOrder.findIndex(i => i === idx);
-
-  if (!original) {
-    Console.warn(`layer.${idx} is undefined`);
-    return state;
-  }
-  let newLabel = `Copy of ${original.config.label}`;
-  let postfix = 0;
-  // eslint-disable-next-line no-loop-func
-  while (layers.find(l => l.config.label === newLabel)) {
-    newLabel = `Copy of ${original.config.label} ${++postfix}`;
-  }
-
-  // collect layer config from original
-  const loadedLayer = serializeLayer(original);
-
-  // assign new id and label to copied layer
-  if (!loadedLayer.config) {
-    return state;
-  }
-  loadedLayer.config.label = newLabel;
-  loadedLayer.id = generateHashId(LAYER_ID_LENGTH);
-
-  // add layer to state
-  let nextState = addLayerUpdater(state, {config: loadedLayer});
-
-  // new added layer are at the end, move it to be on top of original layer
-  const newLayerOrderIdx = nextState.layerOrder.length - 1;
-  const newLayerOrder = arrayInsert(
-    nextState.layerOrder.slice(0, newLayerOrderIdx),
-    originalLayerOrderIdx,
-    newLayerOrderIdx
-  );
-
-  nextState = {
-    ...nextState,
-    layerOrder: newLayerOrder
-  };
-
-  return updateAnimationDomain(nextState);
-};
-
-/**
- * Reorder layer
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').reorderLayerUpdater}
- * @public
- */
-export const reorderLayerUpdater = (state, {order}) => ({
-  ...state,
-  layerOrder: order
-});
-
-/**
- * Remove a dataset and all layers, filters, tooltip configs that based on it
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').removeDatasetUpdater}
- * @public
- */
-export const removeDatasetUpdater = (state, action) => {
-  // extract dataset key
-  const {dataId: datasetKey} = action;
-  const {datasets} = state;
-
-  // check if dataset is present
-  if (!datasets[datasetKey]) {
-    return state;
-  }
-
-  /* eslint-disable no-unused-vars */
-  const {
-    layers,
-    datasets: {[datasetKey]: dataset, ...newDatasets}
-  } = state;
-  /* eslint-enable no-unused-vars */
-
-  const indexes = layers.reduce((listOfIndexes, layer, index) => {
-    if (layer.config.dataId === datasetKey) {
-      // @ts-ignore
-      listOfIndexes.push(index);
-    }
-    return listOfIndexes;
-  }, []);
-
-  // remove layers and datasets
-  const {newState} = indexes.reduce(
-    ({newState: currentState, indexCounter}, idx) => {
-      const currentIndex = idx - indexCounter;
-      currentState = removeLayerUpdater(currentState, {idx: currentIndex});
-      indexCounter++;
-      return {newState: currentState, indexCounter};
-    },
-    {newState: {...state, datasets: newDatasets}, indexCounter: 0}
-  );
-
-  // remove filters
-  const filters = state.filters.filter(filter => !filter.dataId.includes(datasetKey));
-
-  // update interactionConfig
-  let {interactionConfig} = state;
-  const {tooltip} = interactionConfig;
-  if (tooltip) {
-    const {config} = tooltip;
-    /* eslint-disable no-unused-vars */
-    const {[datasetKey]: fields, ...fieldsToShow} = config.fieldsToShow;
-    /* eslint-enable no-unused-vars */
-    interactionConfig = {
-      ...interactionConfig,
-      tooltip: {...tooltip, config: {...config, fieldsToShow}}
-    };
-  }
-
-  return {...newState, filters, interactionConfig};
-};
-
-/**
- * update layer blending mode
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').updateLayerBlendingUpdater}
- * @public
- */
-export const updateLayerBlendingUpdater = (state, action) => ({
-  ...state,
-  layerBlending: action.mode
-});
-
-/**
- * Display dataset table in a modal
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').showDatasetTableUpdater}
- * @public
- */
-export const showDatasetTableUpdater = (state, action) => {
-  return {
-    ...state,
-    editingDataset: action.dataId
-  };
-};
-
-/**
- * reset visState to initial State
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').resetMapConfigUpdater}
- * @public
- */
-export const resetMapConfigUpdater = state => ({
-  ...INITIAL_VIS_STATE,
-  ...state.initialState,
-  initialState: state.initialState
-});
-
-/**
- * Propagate `visState` reducer with a new configuration. Current config will be override.
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').receiveMapConfigUpdater}
- * @public
- */
-export const receiveMapConfigUpdater = (state, {payload: {config = {}, options = {}}}) => {
-  if (!config.visState) {
-    return state;
-  }
-
-  const {keepExistingConfig} = options;
-
-  // reset config if keepExistingConfig is falsy
-  let mergedState = !keepExistingConfig ? resetMapConfigUpdater(state) : state;
-  for (const merger of state.mergers) {
-    if (isValidMerger(merger) && config.visState[merger.prop]) {
-      mergedState = merger.merge(mergedState, config.visState[merger.prop], true);
-    }
-  }
-
-  return mergedState;
-};
-
-/**
- * Trigger layer hover event with hovered object
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').layerHoverUpdater}
- * @public
- */
-export const layerHoverUpdater = (state, action) => ({
-  ...state,
-  hoverInfo: action.info
-});
-
-/* eslint-enable max-statements */
-
-/**
- * Update `interactionConfig`
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').interactionConfigChangeUpdater}
- * @public
- */
-export function interactionConfigChangeUpdater(state, action) {
-  const {config} = action;
-
-  const interactionConfig = {
-    ...state.interactionConfig,
-    ...{[config.id]: config}
-  };
-
-  // Don't enable tooltip and brush at the same time
-  // but coordinates can be shown at all time
-  const contradict = ['brush', 'tooltip'];
-
-  if (
-    contradict.includes(config.id) &&
-    config.enabled &&
-    !state.interactionConfig[config.id].enabled
-  ) {
-    // only enable one interaction at a time
-    contradict.forEach(k => {
-      if (k !== config.id) {
-        interactionConfig[k] = {...interactionConfig[k], enabled: false};
-      }
-    });
-  }
-
-  const newState = {
-    ...state,
-    interactionConfig
-  };
-
-  if (config.id === 'geocoder' && !config.enabled) {
-    return removeDatasetUpdater(newState, {dataId: 'geocoder_dataset'});
-  }
-
-  return newState;
-}
-
-/**
- * Trigger layer click event with clicked object
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').layerClickUpdater}
- * @public
- */
-export const layerClickUpdater = (state, action) => ({
-  ...state,
-  mousePos: state.interactionConfig.coordinate.enabled
-    ? {
-        ...state.mousePos,
-        pinned: state.mousePos.pinned ? null : cloneDeep(state.mousePos)
-      }
-    : state.mousePos,
-  clicked: action.info && action.info.picked ? action.info : null
-});
-
-/**
- * Trigger map click event, unselect clicked object
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').mapClickUpdater}
- * @public
- */
-export const mapClickUpdater = state => {
-  return {
-    ...state,
-    clicked: null
-  };
-};
-
-/**
- * Trigger map move event
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').mouseMoveUpdater}
- * @public
- */
-export const mouseMoveUpdater = (state, {evt}) => {
-  if (Object.values(state.interactionConfig).some(config => config.enabled)) {
-    return {
-      ...state,
-      mousePos: {
-        ...state.mousePos,
-        mousePosition: [...evt.point],
-        coordinate: [...evt.lngLat]
-      }
-    };
-  }
-
-  return state;
-};
-/**
- * Toggle visibility of a layer for a split map
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').toggleSplitMapUpdater}
- * @public
- */
-export const toggleSplitMapUpdater = (state, action) =>
-  state.splitMaps && state.splitMaps.length === 0
-    ? {
-        ...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: computeSplitMapLayers(state.layers)
-      }
-    : closeSpecificMapAtIndex(state, action);
-
-/**
- * Toggle visibility of a layer in a split map
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').toggleLayerForMapUpdater}
- * @public
- */
-export const toggleLayerForMapUpdater = (state, {mapIndex, layerId}) => {
-  const {splitMaps} = state;
-
-  return {
-    ...state,
-    splitMaps: splitMaps.map((sm, i) =>
-      i === mapIndex
-        ? {
-            ...splitMaps[i],
-            layers: {
-              ...splitMaps[i].layers,
-              // if layerId not in layers, set it to visible
-              [layerId]: !splitMaps[i].layers[layerId]
-            }
-          }
-        : sm
-    )
-  };
-};
-
-/**
- * Add new dataset to `visState`, with option to load a map config along with the datasets
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').updateVisDataUpdater}
- * @public
- */
-/* eslint-disable max-statements */
-// eslint-disable-next-line complexity
-export const updateVisDataUpdater = (state, action) => {
-  // datasets can be a single data entries or an array of multiple data entries
-  const {config, options} = action;
-  const datasets = toArray(action.datasets);
-
-  const newDataEntries = datasets.reduce(
-    (accu, {info = {}, ...rest} = {}) => ({
-      ...accu,
-      ...(createNewDataEntry({info, ...rest}, state.datasets) || {})
-    }),
-    {}
-  );
-
-  const dataEmpty = Object.keys(newDataEntries).length < 1;
-
-  // apply config if passed from action
-  const previousState = config
-    ? receiveMapConfigUpdater(state, {
-        payload: {config, options}
-      })
-    : state;
-
-  let mergedState = {
-    ...previousState,
-    datasets: {
-      ...previousState.datasets,
-      ...newDataEntries
-    }
-  };
-
-  // merge state with config to be merged
-  for (const merger of mergedState.mergers) {
-    if (isValidMerger(merger) && merger.toMergeProp && mergedState[merger.toMergeProp]) {
-      const toMerge = mergedState[merger.toMergeProp];
-      mergedState[merger.toMergeProp] = INITIAL_VIS_STATE[merger.toMergeProp];
-      mergedState = merger.merge(mergedState, toMerge);
-    }
-  }
-
-  let newLayers = !dataEmpty
-    ? mergedState.layers.filter(l => l.config.dataId && l.config.dataId in newDataEntries)
-    : [];
-
-  if (!newLayers.length && (options || {}).autoCreateLayers !== false) {
-    // no layer merged, find defaults
-    const 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(
-      l => l.config.dataId && l.config.dataId in newDataEntries
-    );
-    mergedState = {
-      ...mergedState,
-      splitMaps: addNewLayersToSplitMap(mergedState.splitMaps, newLayers)
-    };
-  }
-
-  // if no tooltips merged add default tooltips
-  Object.keys(newDataEntries).forEach(dataId => {
-    const tooltipFields = mergedState.interactionConfig.tooltip.config.fieldsToShow[dataId];
-    if (!Array.isArray(tooltipFields) || !tooltipFields.length) {
-      mergedState = addDefaultTooltips(mergedState, newDataEntries[dataId]);
-    }
-  });
-
-  let 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
- * @type {typeof import('./vis-state-updaters').renameDatasetUpdater}
- * @public
- */
-export function renameDatasetUpdater(state, action) {
-  const {dataId, label} = action;
-  const {datasets} = state;
-  const existing = datasets[dataId];
-  // @ts-ignore
-  return existing
-    ? {
-        ...state,
-        datasets: {
-          ...datasets,
-          [dataId]: {
-            ...existing,
-            label
-          }
-        }
-      }
-    : // No-op if the dataset doesn't exist
-      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
- */
-export function closeSpecificMapAtIndex(state, action) {
-  // retrieve layers meta data from the remaining map that we need to keep
-  const indexToRetrieve = 1 - action.payload;
-  const mapLayers = state.splitMaps[indexToRetrieve].layers;
-  const {layers} = state;
-
-  // update layer visibility
-  const newLayers = layers.map(layer =>
-    !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 {
-    ...state,
-    layers: newLayers,
-    splitMaps: []
-  };
-}
-
-/**
- * Trigger file loading dispatch `addDataToMap` if succeed, or `loadFilesErr` if failed
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').loadFilesUpdater}
- * @public
- */
-export const loadFilesUpdater = (state, action) => {
-  const {files, onFinish = loadFilesSuccess} = action;
-  if (!files.length) {
-    return state;
-  }
-
-  const fileLoadingProgress = Array.from(files).reduce(
-    (accu, f, i) => merge_(initialFileLoadingProgress(f, i))(accu),
-    {}
-  );
-
-  const fileLoading = {
-    fileCache: [],
-    filesToLoad: files,
-    onFinish
-  };
-
-  const nextState = merge_({fileLoadingProgress, fileLoading})(state);
-
-  return loadNextFileUpdater(nextState);
-};
-
-/**
- * Sucessfully loaded one file, move on to the next one
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').loadFileStepSuccessUpdater}
- * @public
- */
-export function loadFileStepSuccessUpdater(state, action) {
-  if (!state.fileLoading) {
-    return state;
-  }
-  const {fileName, fileCache} = action;
-  const {filesToLoad, onFinish} = state.fileLoading;
-  const stateWithProgress = updateFileLoadingProgressUpdater(state, {
-    fileName,
-    progress: {percent: 1, message: 'Done'}
-  });
-
-  // save processed file to fileCache
-  const stateWithCache = pick_('fileLoading')(merge_({fileCache}))(stateWithProgress);
-
-  return withTask(
-    stateWithCache,
-    DELAY_TASK(200).map(filesToLoad.length ? loadNextFile : () => onFinish(fileCache))
-  );
-}
-
-// withTask<T>(state: T, task: any): T
-
-/**
- *
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').loadNextFileUpdater}
- * @public
- */
-export function loadNextFileUpdater(state) {
-  if (!state.fileLoading) {
-    return state;
-  }
-  const {filesToLoad} = state.fileLoading;
-  const [file, ...remainingFilesToLoad] = filesToLoad;
-
-  // save filesToLoad to state
-  const nextState = pick_('fileLoading')(merge_({filesToLoad: remainingFilesToLoad}))(state);
-
-  const stateWithProgress = updateFileLoadingProgressUpdater(nextState, {
-    fileName: file.name,
-    progress: {percent: 0, message: 'loading...'}
-  });
-
-  const {loaders, loadOptions} = state;
-  return withTask(
-    stateWithProgress,
-    makeLoadFileTask(file, nextState.fileLoading.fileCache, loaders, loadOptions)
-  );
-}
-
-export function makeLoadFileTask(file, fileCache, loaders = [], loadOptions = {}) {
-  return LOAD_FILE_TASK({file, fileCache, loaders, loadOptions}).bimap(
-    // prettier ignore
-    // success
-    gen =>
-      nextFileBatch({
-        gen,
-        fileName: file.name,
-        onFinish: result =>
-          processFileContent({
-            content: result,
-            fileCache
-          })
-      }),
-
-    // error
-    err => loadFilesErr(file.name, err)
-  );
-}
-
-/**
- *
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').processFileContentUpdater}
- * @public
- */
-export function processFileContentUpdater(state, action) {
-  const {content, fileCache} = action.payload;
-
-  const stateWithProgress = updateFileLoadingProgressUpdater(state, {
-    fileName: content.fileName,
-    progress: {percent: 1, message: 'processing...'}
-  });
-
-  return withTask(
-    stateWithProgress,
-    PROCESS_FILE_DATA({content, fileCache}).bimap(
-      result => loadFileStepSuccess({fileName: content.fileName, fileCache: result}),
-      err => loadFilesErr(content.fileName, err)
-    )
-  );
-}
-
-export function parseProgress(prevProgress = {}, progress) {
-  // 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
- * @type {typeof import('./vis-state-updaters').nextFileBatchUpdater}
- * @public
- */
-export const nextFileBatchUpdater = (
-  state,
-  {payload: {gen, fileName, progress, accumulated, onFinish}}
-) => {
-  const stateWithProgress = updateFileLoadingProgressUpdater(state, {
-    fileName,
-    progress: parseProgress(state.fileLoadingProgress[fileName], progress)
-  });
-  return withTask(
-    stateWithProgress,
-    UNWRAP_TASK(gen.next()).bimap(
-      ({value, done}) => {
-        return done
-          ? onFinish(accumulated)
-          : nextFileBatch({
-              gen,
-              fileName,
-              progress: value.progress,
-              accumulated: value,
-              onFinish
-            });
-      },
-      err => loadFilesErr(fileName, err)
-    )
-  );
-};
-
-/**
- * Trigger loading file error
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').loadFilesErrUpdater}
- * @public
- */
-export const loadFilesErrUpdater = (state, {error, fileName}) => {
-  // update ui with error message
-  Console.warn(error);
-  if (!state.fileLoading) {
-    return state;
-  }
-  const {filesToLoad, onFinish, fileCache} = state.fileLoading;
-
-  const nextState = updateFileLoadingProgressUpdater(state, {
-    fileName,
-    progress: {error}
-  });
-
-  // kick off next file or finish
-  return withTask(
-    nextState,
-    DELAY_TASK(200).map(filesToLoad.length ? loadNextFile : () => onFinish(fileCache))
-  );
-};
-
-/**
- * When select dataset for export, apply cpu filter to selected dataset
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').applyCPUFilterUpdater}
- * @public
- */
-export const applyCPUFilterUpdater = (state, {dataId}) => {
-  // apply cpuFilter
-  const dataIds = toArray(dataId);
-
-  return dataIds.reduce((accu, id) => filterDatasetCPU(accu, id), state);
-};
-
-/**
- * User input to update the info of the map
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').setMapInfoUpdater}
- * @public
- */
-export const setMapInfoUpdater = (state, action) => ({
-  ...state,
-  mapInfo: {
-    ...state.mapInfo,
-    ...action.info
-  }
-});
-/**
- * Helper function to update All layer domain and layer data of state
- * @type {typeof import('./vis-state-updaters').addDefaultLayers}
- */
-export function addDefaultLayers(state, datasets) {
-  /** @type {Layer[]} */
-  const empty = [];
-  const defaultLayers = Object.values(datasets).reduce((accu, dataset) => {
-    const foundLayers = findDefaultLayer(dataset, state.layerClasses);
-    return foundLayers && foundLayers.length ? accu.concat(foundLayers) : accu;
-  }, empty);
-
-  return {
-    state: {
-      ...state,
-      layers: [...state.layers, ...defaultLayers],
-      layerOrder: [
-        // put new layers on top of old ones
-        ...defaultLayers.map((_, i) => state.layers.length + i),
-        ...state.layerOrder
-      ]
-    },
-    newLayers: defaultLayers
-  };
-}
-
-/**
- * helper function to find default tooltips
- * @param {Object} state
- * @param {Object} dataset
- * @returns {Object} nextState
- */
-export function addDefaultTooltips(state, dataset) {
-  const tooltipFields = dataset.metadata.isDynamicSpatialIndex
-    ? {[dataset.id]: []}
-    : findFieldsToShow(dataset);
-  const merged = {
-    ...state.interactionConfig.tooltip.config.fieldsToShow,
-    ...tooltipFields
-  };
-
-  return set(['interactionConfig', 'tooltip', 'config', 'fieldsToShow'], merged, state);
-}
-
-export function initialFileLoadingProgress(file, index) {
-  const fileName = file.name || `Untitled File ${index}`;
-  return {
-    [fileName]: {
-      // percent of current file
-      percent: 0,
-      message: '',
-      fileName,
-      error: null
-    }
-  };
-}
-
-export function updateFileLoadingProgressUpdater(state, {fileName, progress}) {
-  return pick_('fileLoadingProgress')(pick_(fileName)(merge_(progress)))(state);
-}
-/**
- * Helper function to update layer domains for an array of datasets
- * @type {typeof import('./vis-state-updaters').updateAllLayerDomainData}
- */
-export function updateAllLayerDomainData(state, dataId, updatedFilter) {
-  const dataIds = typeof dataId === 'string' ? [dataId] : dataId;
-  const newLayers = [];
-  const newLayerData = [];
-
-  state.layers.forEach((oldLayer, i) => {
-    if (oldLayer.config.dataId && dataIds.includes(oldLayer.config.dataId)) {
-      // No need to recalculate layer domain if filter has fixed domain
-      const newLayer =
-        updatedFilter && updatedFilter.fixedDomain
-          ? oldLayer
-          : oldLayer.updateLayerDomain(state.datasets, updatedFilter);
-
-      const {layerData, layer} = calculateLayerData(newLayer, state, state.layerData[i]);
-
-      newLayers.push(layer);
-      newLayerData.push(layerData);
-    } else {
-      newLayers.push(oldLayer);
-      newLayerData.push(state.layerData[i]);
-    }
-  });
-
-  const newState = {
-    ...state,
-    layers: newLayers,
-    layerData: newLayerData
-  };
-
-  return newState;
-}
-
-export function updateAnimationDomain(state) {
-  // merge all animatable layer domain and update global config
-  const animatableLayers = state.layers.filter(
-    l =>
-      l.config.isVisible &&
-      l.config.animation &&
-      l.config.animation.enabled &&
-      Array.isArray(l.animationDomain)
-  );
-
-  if (!animatableLayers.length) {
-    return {
-      ...state,
-      animationConfig: {
-        ...state.animationConfig,
-        domain: null,
-        defaultTimeFormat: null
-      }
-    };
-  }
-
-  const mergedDomain = animatableLayers.reduce(
-    (accu, layer) => [
-      Math.min(accu[0], layer.animationDomain[0]),
-      Math.max(accu[1], layer.animationDomain[1])
-    ],
-    [Number(Infinity), -Infinity]
-  );
-  const defaultTimeFormat = getTimeWidgetTitleFormatter(mergedDomain);
-
-  return {
-    ...state,
-    animationConfig: {
-      ...state.animationConfig,
-      currentTime: isInRange(state.animationConfig.currentTime, mergedDomain)
-        ? state.animationConfig.currentTime
-        : mergedDomain[0],
-      domain: mergedDomain,
-      defaultTimeFormat
-    }
-  };
-}
-
-/**
- * Update the status of the editor
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').setEditorModeUpdater}
- */
-export const setEditorModeUpdater = (state, {mode}) => ({
-  ...state,
-  editor: {
-    ...state.editor,
-    mode,
-    selectedFeature: null
-  }
-});
-
-// const featureToFilterValue = (feature) => ({...feature, id: feature.id});
-/**
- * Update editor features
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').setFeaturesUpdater}
- */
-export function setFeaturesUpdater(state, {features = []}) {
-  const lastFeature = features.length && features[features.length - 1];
-
-  const newState = {
-    ...state,
-    editor: {
-      ...state.editor,
-      // only save none filter features to editor
-      features: features.filter(f => !getFilterIdInFeature(f)),
-      mode: lastFeature && lastFeature.properties.isClosed ? EDITOR_MODES.EDIT : state.editor.mode
-    }
-  };
-
-  // Retrieve existing feature
-  const {selectedFeature} = state.editor;
-
-  // If no feature is selected we can simply return since no operations
-  if (!selectedFeature) {
-    return newState;
-  }
-
-  // TODO: check if the feature has changed
-  const feature = features.find(f => f.id === selectedFeature.id);
-
-  // if feature is part of a filter
-  const filterId = feature && getFilterIdInFeature(feature);
-  if (filterId && feature) {
-    const featureValue = featureToFilterValue(feature, filterId);
-    const filterIdx = state.filters.findIndex(fil => fil.id === filterId);
-    return setFilterUpdater(newState, {
-      idx: filterIdx,
-      prop: 'value',
-      value: featureValue
-    });
-  }
-
-  return newState;
-}
-
-/**
- * Set the current selected feature
- * @memberof uiStateUpdaters
- * @type {typeof import('./vis-state-updaters').setSelectedFeatureUpdater}
- */
-export const setSelectedFeatureUpdater = (state, {feature}) => ({
-  ...state,
-  editor: {
-    ...state.editor,
-    selectedFeature: feature
-  }
-});
-
-/**
- * Delete existing feature from filters
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').deleteFeatureUpdater}
- */
-export function deleteFeatureUpdater(state, {feature}) {
-  if (!feature) {
-    return state;
-  }
-
-  const newState = {
-    ...state,
-    editor: {
-      ...state.editor,
-      selectedFeature: null
-    }
-  };
-
-  if (getFilterIdInFeature(feature)) {
-    const filterIdx = newState.filters.findIndex(f => f.id === getFilterIdInFeature(feature));
-
-    return filterIdx > -1 ? removeFilterUpdater(newState, {idx: filterIdx}) : newState;
-  }
-
-  // modify editor object
-  const newEditor = {
-    ...state.editor,
-    features: state.editor.features.filter(f => f.id !== feature.id),
-    selectedFeature: null
-  };
-
-  return {
-    ...state,
-    editor: newEditor
-  };
-}
-
-/**
- * Toggle feature as layer filter
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').setPolygonFilterLayerUpdater}
- */
-export function setPolygonFilterLayerUpdater(state, payload) {
-  const {layer, feature} = payload;
-  const filterId = getFilterIdInFeature(feature);
-
-  // let newFilter = null;
-  let filterIdx;
-  let newLayerId = [layer.id];
-  let 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(f => 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
-      const noneFilterFeature = {
-        ...feature,
-        properties: {
-          ...feature.properties,
-          filterId: null
-        }
-      };
-
-      return {
-        ...state,
-        editor: {
-          ...state.editor,
-          features: [...state.editor.features, noneFilterFeature],
-          selectedFeature: noneFilterFeature
-        }
-      };
-    }
-    const filter = state.filters[filterIdx];
-    const {layerId = []} = filter;
-    const isLayerIncluded = layerId.includes(layer.id);
-
-    newLayerId = isLayerIncluded
-      ? // if layer is included, remove it
-        layerId.filter(l => l !== layer.id)
-      : [...layerId, layer.id];
-  } else {
-    // if we haven't create the polygon filter, create it
-    const newFilter = generatePolygonFilter([], feature);
-    filterIdx = state.filters.length;
-
-    // add feature, remove feature from eidtor
-    newState = {
-      ...state,
-      filters: [...state.filters, newFilter],
-      editor: {
-        ...state.editor,
-        features: state.editor.features.filter(f => f.id !== feature.id),
-        selectedFeature: newFilter.value
-      }
-    };
-  }
-
-  return setFilterUpdater(newState, {
-    idx: filterIdx,
-    prop: 'layerId',
-    value: newLayerId
-  });
-}
-
-/**
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').sortTableColumnUpdater}
- * @public
- */
-export function sortTableColumnUpdater(state, {dataId, column, mode}) {
-  const dataset = state.datasets[dataId];
-  if (!dataset) {
-    return state;
-  }
-  let sortMode = mode;
-  if (!sortMode) {
-    const currentMode = get(dataset, ['sortColumn', column]);
-    // @ts-ignore - should be fixable in a TS file
-    sortMode = currentMode
-      ? Object.keys(SORT_ORDER).find(m => m !== currentMode)
-      : SORT_ORDER.ASCENDING;
-  }
-
-  const sorted = sortDatasetByColumn(dataset, column, sortMode);
-  return set(['datasets', dataId], sorted, state);
-}
-
-/**
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').pinTableColumnUpdater}
- * @public
- */
-export function pinTableColumnUpdater(state, {dataId, column}) {
-  const dataset = state.datasets[dataId];
-  if (!dataset) {
-    return state;
-  }
-  const field = dataset.fields.find(f => f.name === column);
-  if (!field) {
-    return state;
-  }
-
-  let pinnedColumns;
-  if (Array.isArray(dataset.pinnedColumns) && dataset.pinnedColumns.includes(field.name)) {
-    // unpin it
-    pinnedColumns = dataset.pinnedColumns.filter(co => co !== field.name);
-  } else {
-    pinnedColumns = (dataset.pinnedColumns || []).concat(field.name);
-  }
-
-  return set(['datasets', dataId, 'pinnedColumns'], pinnedColumns, state);
-}
-
-/**
- * Copy column content as strings
- * @memberof visStateUpdaters
- * @type {typeof import('./vis-state-updaters').copyTableColumnUpdater}
- * @public
- */
-export function copyTableColumnUpdater(state, {dataId, column}) {
-  const dataset = state.datasets[dataId];
-  if (!dataset) {
-    return state;
-  }
-  const fieldIdx = dataset.fields.findIndex(f => f.name === column);
-  if (fieldIdx < 0) {
-    return state;
-  }
-  const {type} = dataset.fields[fieldIdx];
-  const text = dataset.dataContainer
-    .map(row => parseFieldValue(row.valueAt(fieldIdx), type), true)
-    .join('\n');
-
-  copy(text);
-
-  return state;
-}
-
-/**
- * Update editor
- * @type {typeof import('./vis-state-updaters').toggleEditorVisibilityUpdater}
- */
-export function toggleEditorVisibilityUpdater(state) {
-  return {
-    ...state,
-    editor: {
-      ...state.editor,
-      visible: !state.editor.visible
-    }
-  };
-}
-
-export function setFilterAnimationTimeConfigUpdater(state, {idx, config}) {
-  const oldFilter = state.filters[idx];
-  if (!oldFilter) {
-    Console.error(`filters.${idx} is undefined`);
-    return state;
-  }
-  if (oldFilter.type !== FILTER_TYPES.timeRange) {
-    Console.error(
-      `setFilterAnimationTimeConfig can only be called to update a time filter. check filter.type === 'timeRange'`
-    );
-    return state;
-  }
-
-  const updates = checkTimeConfigArgs(config);
-
-  return pick_('filters')(swap_(merge_(updates)(oldFilter)))(state);
-}
-
-function checkTimeConfigArgs(config) {
-  const allowed = ['timeFormat', 'timezone'];
-  return Object.keys(config).reduce((accu, prop) => {
-    if (!allowed.includes(prop)) {
-      Console.error(
-        `setLayerAnimationTimeConfig takes timeFormat and/or timezone as options, found ${prop}`
-      );
-      return accu;
-    }
-
-    // here we are NOT checking if timezone or timeFormat input is valid
-    accu[prop] = config[prop];
-    return accu;
-  }, {});
-}
-/**
- * Update editor
- * @type {typeof import('./vis-state-updaters').setLayerAnimationTimeConfigUpdater}
- */
-export function setLayerAnimationTimeConfigUpdater(state, {config}) {
-  if (!config) {
-    return state;
-  }
-  const updates = checkTimeConfigArgs(config);
-  return pick_('animationConfig')(merge_(updates))(state);
-}