@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/actions/vis-state-actions.js

@@ -0,0 +1,1045 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.layerConfigChange = layerConfigChange;
+exports.layerTextLabelChange = layerTextLabelChange;
+exports.layerTypeChange = layerTypeChange;
+exports.layerVisualChannelConfigChange = layerVisualChannelConfigChange;
+exports.layerVisConfigChange = layerVisConfigChange;
+exports.layerColorUIChange = layerColorUIChange;
+exports.updateLayerBlending = updateLayerBlending;
+exports.interactionConfigChange = interactionConfigChange;
+exports.setFilter = setFilter;
+exports.setFilterAnimationTime = setFilterAnimationTime;
+exports.setFilterAnimationWindow = setFilterAnimationWindow;
+exports.addFilter = addFilter;
+exports.addLayer = addLayer;
+exports.reorderLayer = reorderLayer;
+exports.removeFilter = removeFilter;
+exports.removeLayer = removeLayer;
+exports.duplicateLayer = duplicateLayer;
+exports.removeDataset = removeDataset;
+exports.showDatasetTable = showDatasetTable;
+exports.sortTableColumn = sortTableColumn;
+exports.pinTableColumn = pinTableColumn;
+exports.copyTableColumn = copyTableColumn;
+exports.updateVisData = updateVisData;
+exports.renameDataset = renameDataset;
+exports.toggleFilterAnimation = toggleFilterAnimation;
+exports.updateFilterAnimationSpeed = updateFilterAnimationSpeed;
+exports.setLayerAnimationTime = setLayerAnimationTime;
+exports.updateLayerAnimationSpeed = updateLayerAnimationSpeed;
+exports.toggleLayerAnimation = toggleLayerAnimation;
+exports.toggleLayerAnimationControl = toggleLayerAnimationControl;
+exports.enlargeFilter = enlargeFilter;
+exports.toggleFilterFeature = toggleFilterFeature;
+exports.onLayerHover = onLayerHover;
+exports.onLayerClick = onLayerClick;
+exports.onMapClick = onMapClick;
+exports.onMouseMove = onMouseMove;
+exports.toggleLayerForMap = toggleLayerForMap;
+exports.setFilterPlot = setFilterPlot;
+exports.setMapInfo = setMapInfo;
+exports.loadFiles = loadFiles;
+exports.loadNextFile = loadNextFile;
+exports.loadFilesSuccess = loadFilesSuccess;
+exports.loadFileStepSuccess = loadFileStepSuccess;
+exports.loadFilesErr = loadFilesErr;
+exports.setFeatures = setFeatures;
+exports.setPolygonFilterLayer = setPolygonFilterLayer;
+exports.setSelectedFeature = setSelectedFeature;
+exports.deleteFeature = deleteFeature;
+exports.setEditorMode = setEditorMode;
+exports.applyCPUFilter = applyCPUFilter;
+exports.toggleEditorVisibility = toggleEditorVisibility;
+exports.nextFileBatch = nextFileBatch;
+exports.processFileContent = processFileContent;
+exports.setLayerAnimationTimeConfig = setLayerAnimationTimeConfig;
+exports.setFilterAnimationTimeConfig = setFilterAnimationTimeConfig;
+
+var _actionTypes = _interopRequireDefault(require("../constants/action-types"));
+
+// 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.
+// vis-state-reducer
+
+/**
+ * Update layer base config: dataId, label, column, isVisible
+ * @param oldLayer - layer to be updated
+ * @param newConfig - new config to be merged with old config
+ * @returns action
+ * @type {typeof import('./vis-state-actions').layerConfigChange}
+ * @public
+ */
+function layerConfigChange(oldLayer, newConfig) {
+  return {
+    type: _actionTypes["default"].LAYER_CONFIG_CHANGE,
+    oldLayer: oldLayer,
+    newConfig: newConfig
+  };
+}
+/**
+ * Update layer text label
+ * @param oldLayer - layer to be updated
+ * @param idx -`idx` of text label to be updated
+ * @param prop - `prop` of text label, e,g, `anchor`, `alignment`, `color`, `size`, `field`
+ * @param value - new value
+ * @returns action
+ * @type {typeof import('./vis-state-actions').layerTextLabelChange}
+ * @public
+ */
+
+
+function layerTextLabelChange(oldLayer, idx, prop, value) {
+  return {
+    type: _actionTypes["default"].LAYER_TEXT_LABEL_CHANGE,
+    oldLayer: oldLayer,
+    idx: idx,
+    prop: prop,
+    value: value
+  };
+}
+/**
+ * Update layer type. Previews layer config will be copied if applicable.
+ * @param oldLayer - layer to be updated
+ * @param newType - new type
+ * @returns action
+ * @type {typeof import('./vis-state-actions').layerTypeChange}
+ * @public
+ */
+
+
+function layerTypeChange(oldLayer, newType) {
+  return {
+    type: _actionTypes["default"].LAYER_TYPE_CHANGE,
+    oldLayer: oldLayer,
+    newType: newType
+  };
+}
+/**
+ * Update layer visual channel
+ * @memberof visStateActions
+ * @param oldLayer - layer to be updated
+ * @param newConfig - new visual channel config
+ * @param channel - channel to be updated
+ * @returns action
+ * @type {typeof import('./vis-state-actions').layerVisualChannelConfigChange}
+ * @public
+ */
+
+
+function layerVisualChannelConfigChange(oldLayer, newConfig, channel) {
+  return {
+    type: _actionTypes["default"].LAYER_VISUAL_CHANNEL_CHANGE,
+    oldLayer: oldLayer,
+    newConfig: newConfig,
+    channel: channel
+  };
+}
+/**
+ * Update layer `visConfig`
+ * @memberof visStateActions
+ * @param oldLayer - layer to be updated
+ * @param newVisConfig - new visConfig as a key value map: e.g. `{opacity: 0.8}`
+ * @returns action
+ * @type {typeof import('./vis-state-actions').layerVisConfigChange}
+ * @public
+ */
+
+
+function layerVisConfigChange(oldLayer, newVisConfig) {
+  return {
+    type: _actionTypes["default"].LAYER_VIS_CONFIG_CHANGE,
+    oldLayer: oldLayer,
+    newVisConfig: newVisConfig
+  };
+}
+/**
+ * Set the color palette ui for layer color
+ * @memberOf visStateActions
+ * @param oldLayer - layer to be updated
+ * @param prop - which color prop
+ * @param newConfig - to be merged
+ * @returns action
+ * @type {typeof import('./vis-state-actions').layerColorUIChange}
+ * @public
+ */
+
+
+function layerColorUIChange(oldLayer, prop, newConfig) {
+  return {
+    type: _actionTypes["default"].LAYER_COLOR_UI_CHANGE,
+    oldLayer: oldLayer,
+    prop: prop,
+    newConfig: newConfig
+  };
+}
+/**
+ * Update layer blending mode
+ * @memberof visStateActions
+ * @param mode one of `additive`, `normal` and `subtractive`
+ * @returns action
+ * @type {typeof import('./vis-state-actions').updateLayerBlending}
+ * @public
+ */
+
+
+function updateLayerBlending(mode) {
+  return {
+    type: _actionTypes["default"].UPDATE_LAYER_BLENDING,
+    mode: mode
+  };
+}
+/**
+ * Update `interactionConfig`
+ * @memberof visStateActions
+ * @param config - new config as key value map: `{tooltip: {enabled: true}}`
+ * @returns action
+ * @type {typeof import('./vis-state-actions').interactionConfigChange}
+ * @public
+ */
+
+
+function interactionConfigChange(config) {
+  return {
+    type: _actionTypes["default"].INTERACTION_CONFIG_CHANGE,
+    config: config
+  };
+}
+/**
+ * Update filter property
+ * @memberof visStateActions
+ * @param idx -`idx` of filter to be updated
+ * @param prop - `prop` of filter, e,g, `dataId`, `name`, `value`
+ * @param value - new value
+ * @param valueIndex - dataId index
+ * @returns action
+ * @type {typeof import('./vis-state-actions').setFilter}
+ * @public
+ */
+
+
+function setFilter(idx, prop, value, valueIndex) {
+  return {
+    type: _actionTypes["default"].SET_FILTER,
+    idx: idx,
+    prop: prop,
+    value: value,
+    valueIndex: valueIndex
+  };
+}
+/**
+ * Same as Update filter
+ * @memberof visStateActions
+ * @param idx -`idx` of filter to be updated
+ * @param prop - `prop` of filter, e,g, `dataId`, `name`, `value`
+ * @param value - new value
+ * @param valueIndex - dataId index
+ * @returns action
+ * @type {typeof import('./vis-state-actions').setFilterAnimationTime}
+ * @public
+ */
+
+
+function setFilterAnimationTime(idx, prop, value, valueIndex) {
+  return {
+    type: _actionTypes["default"].SET_FILTER_ANIMATION_TIME,
+    idx: idx,
+    prop: prop,
+    value: value,
+    valueIndex: valueIndex
+  };
+}
+/**
+ * Same as Update filter
+ * @memberof visStateActions
+ * @type {typeof import('./vis-state-actions').setFilterAnimationWindow}
+ * @public
+ */
+
+
+function setFilterAnimationWindow(_ref) {
+  var id = _ref.id,
+      animationWindow = _ref.animationWindow;
+  return {
+    type: _actionTypes["default"].SET_FILTER_ANIMATION_WINDOW,
+    id: id,
+    animationWindow: animationWindow
+  };
+}
+/**
+ * Add a new filter
+ * @memberof visStateActions
+ * @param dataId - dataset `id` this new filter is associated with
+ * @returns action
+ * @type {typeof import('./vis-state-actions').addFilter}
+ * @public
+ */
+
+
+function addFilter(dataId) {
+  return {
+    type: _actionTypes["default"].ADD_FILTER,
+    dataId: dataId
+  };
+}
+/**
+ * Add a new layer
+ * @memberof visStateActions
+ * @param config - new layer config
+ * @returns action
+ * @type {typeof import('./vis-state-actions').addLayer}
+ * @public
+ */
+
+
+function addLayer(config) {
+  return {
+    type: _actionTypes["default"].ADD_LAYER,
+    config: config
+  };
+}
+/**
+ * Reorder layer, order is an array of layer indexes, index 0 will be the one at the bottom
+ * @memberof visStateActions
+ * @param order an array of layer indexes
+ * @returns action
+ * @type {typeof import('./vis-state-actions').reorderLayer}
+ * @public
+ * @example
+ *
+ * // bring `layers[1]` below `layers[0]`, the sequence layers will be rendered is `1`, `0`, `2`, `3`.
+ * // `1` will be at the bottom, `3` will be at the top.
+ * this.props.dispatch(reorderLayer([1, 0, 2, 3]));
+ */
+
+
+function reorderLayer(order) {
+  return {
+    type: _actionTypes["default"].REORDER_LAYER,
+    order: order
+  };
+}
+/**
+ * Remove a filter from `visState.filters`, once a filter is removed, data will be re-filtered and layer will be updated
+ * @memberof visStateActions
+ * @param idx idx of filter to be removed
+ * @returns action
+ * @type {typeof import('./vis-state-actions').removeFilter}
+ * @public
+ */
+
+
+function removeFilter(idx) {
+  return {
+    type: _actionTypes["default"].REMOVE_FILTER,
+    idx: idx
+  };
+}
+/**
+ * Remove a layer
+ * @memberof visStateActions
+ * @param idx idx of layer to be removed
+ * @returns action
+ * @type {typeof import('./vis-state-actions').removeLayer}
+ * @public
+ */
+
+
+function removeLayer(idx) {
+  return {
+    type: _actionTypes["default"].REMOVE_LAYER,
+    idx: idx
+  };
+}
+/**
+ * Duplicate a layer
+ * @memberof visStateActions
+ * @param idx idx of layer to be duplicated
+ * @returns action
+ * @type {typeof import('./vis-state-actions').duplicateLayer}
+ * @public
+ */
+
+
+function duplicateLayer(idx) {
+  return {
+    type: _actionTypes["default"].DUPLICATE_LAYER,
+    idx: idx
+  };
+}
+/**
+ * Remove a dataset and all layers, filters, tooltip configs that based on it
+ * @memberof visStateActions
+ * @param dataId dataset id
+ * @returns action
+ * @type {typeof import('./vis-state-actions').removeDataset}
+ * @public
+ */
+
+
+function removeDataset(dataId) {
+  return {
+    type: _actionTypes["default"].REMOVE_DATASET,
+    dataId: dataId
+  };
+}
+/**
+ * Display dataset table in a modal
+ * @memberof visStateActions
+ * @param dataId dataset id to show in table
+ * @returns action
+ * @type {typeof import('./vis-state-actions').showDatasetTable}
+ * @public
+ */
+
+
+function showDatasetTable(dataId) {
+  return {
+    type: _actionTypes["default"].SHOW_DATASET_TABLE,
+    dataId: dataId
+  };
+}
+/**
+ * Sort dataset column, for table display
+ * @memberof visStateActions
+ * @param dataId
+ * @param column
+ * @param mode
+ * @returns action
+ * @type {typeof import('./vis-state-actions').sortTableColumn}
+ * @public
+ */
+
+
+function sortTableColumn(dataId, column, mode) {
+  return {
+    type: _actionTypes["default"].SORT_TABLE_COLUMN,
+    dataId: dataId,
+    column: column,
+    mode: mode
+  };
+}
+/**
+ * Pin dataset column, for table display
+ * @param dataId
+ * @param column
+ * @returns action
+ * @type {typeof import('./vis-state-actions').pinTableColumn}
+ * @public
+ */
+
+
+function pinTableColumn(dataId, column) {
+  return {
+    type: _actionTypes["default"].PIN_TABLE_COLUMN,
+    dataId: dataId,
+    column: column
+  };
+}
+/**
+ * Copy column, for table display
+ * @param dataId
+ * @param column
+ * @returns action
+ * @type {typeof import('./vis-state-actions').copyTableColumn}
+ * @public
+ */
+
+
+function copyTableColumn(dataId, column) {
+  return {
+    type: _actionTypes["default"].COPY_TABLE_COLUMN,
+    dataId: dataId,
+    column: column
+  };
+} // * @param dataset.info -info of a dataset
+// * @param dataset.info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.
+// * @param dataset.info.label - A display name of this dataset
+// * @param dataset.data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`
+// * @param dataset.data.fields - ***required** Array of fields,
+// * @param dataset.data.fields.name - ***required** Name of the field,
+// * @param dataset.data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`
+
+/**
+ * Add new dataset to `visState`, with option to load a map config along with the datasets
+ * @memberof visStateActions
+ * @param datasets - ***required** datasets can be a dataset or an array of datasets
+ * Each dataset object needs to have `info` and `data` property.
+ * @param {object} options
+ * @param options.centerMap `default: true` if `centerMap` is set to `true` kepler.gl will
+ * place the map view within the data points boundaries
+ * @param options.readOnly `default: false` if `readOnly` is set to `true`
+ * the left setting panel will be hidden
+ * @param config this object will contain the full kepler.gl instance configuration {mapState, mapStyle, visState}
+ * @returns action
+ * @type {typeof import('./vis-state-actions').updateVisData}
+ * @public
+ */
+
+
+function updateVisData(datasets, options, config) {
+  return {
+    type: _actionTypes["default"].UPDATE_VIS_DATA,
+    datasets: datasets,
+    options: options,
+    config: config
+  };
+}
+/**
+ * Rename an existing dataset in `visState`
+ * @memberof visStateActions
+ * @param dataId - ***required** Id of the dataset to update
+ * @param label - ***required** New name for the dataset
+ * @returns action
+ * @type {typeof import('./vis-state-actions').renameDataset}
+ * @public
+ */
+
+
+function renameDataset(dataId, label) {
+  return {
+    type: _actionTypes["default"].RENAME_DATASET,
+    dataId: dataId,
+    label: label
+  };
+}
+/**
+ * Start and end filter animation
+ * @memberof visStateActions
+ * @param {Number} idx of filter
+ * @type {typeof import('./vis-state-actions').toggleFilterAnimation}
+ * @returns action
+ * @public
+ */
+
+
+function toggleFilterAnimation(idx) {
+  return {
+    type: _actionTypes["default"].TOGGLE_FILTER_ANIMATION,
+    idx: idx
+  };
+}
+/**
+ * Change filter animation speed
+ * @memberof visStateActions
+ * @param idx -  `idx` of filter
+ * @param speed - `speed` to change it to. `speed` is a multiplier
+ * @type {typeof import('./vis-state-actions').updateFilterAnimationSpeed}
+ * @returns action
+ * @public
+ */
+
+
+function updateFilterAnimationSpeed(idx, speed) {
+  return {
+    type: _actionTypes["default"].UPDATE_FILTER_ANIMATION_SPEED,
+    idx: idx,
+    speed: speed
+  };
+}
+/**
+ * Reset animation
+ * @memberof visStateActions
+ * @param value -  Current value of the slider
+ * @type {typeof import('./vis-state-actions').setLayerAnimationTime}
+ * @returns action
+ * @public
+ */
+
+
+function setLayerAnimationTime(value) {
+  return {
+    type: _actionTypes["default"].SET_LAYER_ANIMATION_TIME,
+    value: value
+  };
+}
+/**
+ * update trip layer animation speed
+ * @memberof visStateActions
+ * @param speed - `speed` to change it to. `speed` is a multiplier
+ * @type {typeof import('./vis-state-actions').updateLayerAnimationSpeed}
+ * @returns action
+ * @public
+ */
+
+
+function updateLayerAnimationSpeed(speed) {
+  return {
+    type: _actionTypes["default"].UPDATE_LAYER_ANIMATION_SPEED,
+    speed: speed
+  };
+}
+/**
+ * start end end layer animation
+ * @memberof visStateActions
+ * @type {typeof import('./vis-state-actions').toggleLayerAnimation}
+ * @returns action
+ * @public
+ */
+
+
+function toggleLayerAnimation() {
+  return {
+    type: _actionTypes["default"].TOGGLE_LAYER_ANIMATION
+  };
+}
+/**
+ * hide and show layer animation control
+ * @memberof visStateActions
+ * @type {typeof import('./vis-state-actions').toggleLayerAnimationControl}
+ * @returns action
+ * @public
+ */
+
+
+function toggleLayerAnimationControl() {
+  return {
+    type: _actionTypes["default"].TOGGLE_LAYER_ANIMATION_CONTROL
+  };
+}
+/**
+ * Show larger time filter at bottom for time playback (apply to time filter only)
+ * @memberof visStateActions
+ * @param idx - index of filter to enlarge
+ * @type {typeof import('./vis-state-actions').enlargeFilter}
+ * @returns action
+ * @public
+ */
+
+
+function enlargeFilter(idx) {
+  return {
+    type: _actionTypes["default"].ENLARGE_FILTER,
+    idx: idx
+  };
+}
+/**
+ * Show/hide filter feature on map
+ * @memberof visStateActions
+ * @param idx - index of filter feature to show/hide
+ * @type {typeof import('./vis-state-actions').toggleFilterFeature}
+ * @return action
+ */
+
+
+function toggleFilterFeature(idx) {
+  return {
+    type: _actionTypes["default"].TOGGLE_FILTER_FEATURE,
+    idx: idx
+  };
+}
+/**
+ * Trigger layer hover event with hovered object
+ * @memberof visStateActions
+ * @param info - Object hovered, returned by deck.gl
+ * @type {typeof import('./vis-state-actions').onLayerHover}
+ * @returns action
+ * @public
+ */
+
+
+function onLayerHover(info) {
+  return {
+    type: _actionTypes["default"].LAYER_HOVER,
+    info: info
+  };
+}
+/**
+ * Trigger layer click event with clicked object
+ * @memberof visStateActions
+ * @param info - Object clicked, returned by deck.gl
+ * @type {typeof import('./vis-state-actions').onLayerClick}
+ * @returns action
+ * @public
+ */
+
+
+function onLayerClick(info) {
+  return {
+    type: _actionTypes["default"].LAYER_CLICK,
+    info: info
+  };
+}
+/**
+ * Trigger map click event, unselect clicked object
+ * @memberof visStateActions
+ * @type {typeof import('./vis-state-actions').onMapClick}
+ * @returns action
+ * @public
+ */
+
+
+function onMapClick() {
+  return {
+    type: _actionTypes["default"].MAP_CLICK
+  };
+}
+/**
+ * Trigger map mouse moveevent, payload would be
+ * React-map-gl PointerEvent
+ * https://uber.github.io/react-map-gl/#/documentation/api-reference/pointer-event
+ *
+ * @memberof visStateActions
+ * @param evt - PointerEvent
+ * @type {typeof import('./vis-state-actions').onMouseMove}
+ * @returns action
+ * @public
+ */
+
+
+function onMouseMove(evt) {
+  return {
+    type: _actionTypes["default"].MOUSE_MOVE,
+    evt: evt
+  };
+}
+/**
+ * Toggle visibility of a layer in a split map
+ * @memberof visStateActions
+ * @param mapIndex - index of the split map
+ * @param layerId - id of the layer
+ * @type {typeof import('./vis-state-actions').toggleLayerForMap}
+ * @returns action
+ * @public
+ */
+
+
+function toggleLayerForMap(mapIndex, layerId) {
+  return {
+    type: _actionTypes["default"].TOGGLE_LAYER_FOR_MAP,
+    mapIndex: mapIndex,
+    layerId: layerId
+  };
+}
+/**
+ * Set the property of a filter plot
+ * @memberof visStateActions
+ * @param idx
+ * @param newProp key value mapping of new prop `{yAxis: 'histogram'}`
+ * @param valueIndex dataId index
+ * @type {typeof import('./vis-state-actions').setFilterPlot}
+ * @returns action
+ * @public
+ */
+
+
+function setFilterPlot(idx, newProp, valueIndex) {
+  return {
+    type: _actionTypes["default"].SET_FILTER_PLOT,
+    idx: idx,
+    newProp: newProp,
+    valueIndex: valueIndex
+  };
+}
+/**
+ * Set the property of a filter plot
+ * @memberof visStateActions
+ * @param info
+ * @type {typeof import('./vis-state-actions').setMapInfo}
+ * @returns action
+ * @public
+ */
+
+
+function setMapInfo(info) {
+  return {
+    type: _actionTypes["default"].SET_MAP_INFO,
+    info: info
+  };
+}
+/**
+ * Trigger file loading dispatch `addDataToMap` if succeed, or `loadFilesErr` if failed
+ * @memberof visStateActions
+ * @param files array of fileblob
+ * @type {typeof import('./vis-state-actions').loadFiles}
+ * @returns action
+ * @public
+ */
+
+
+function loadFiles(files, onFinish) {
+  return {
+    type: _actionTypes["default"].LOAD_FILES,
+    files: files,
+    onFinish: onFinish
+  };
+}
+/**
+ * Called with next file to load
+ * @memberof visStateActions
+ * @type {typeof import('./vis-state-actions').loadNextFile}
+ * @returns action
+ * @public
+ */
+
+
+function loadNextFile() {
+  return {
+    type: _actionTypes["default"].LOAD_NEXT_FILE
+  };
+}
+/**
+ * called when all files are processed and loaded
+ * @memberof visStateActions
+ * @param result
+ * @type {typeof import('./vis-state-actions').loadFilesSuccess}
+ * @returns action
+ */
+
+
+function loadFilesSuccess(result) {
+  return {
+    type: _actionTypes["default"].LOAD_FILES_SUCCESS,
+    result: result
+  };
+}
+/**
+ * called when successfully loaded one file, ready to move on to the next one
+ * @memberof visStateActions
+ * @param result
+ * @type {typeof import('./vis-state-actions').loadFileStepSuccess}
+ * @returns action
+ */
+
+
+function loadFileStepSuccess(_ref2) {
+  var fileName = _ref2.fileName,
+      fileCache = _ref2.fileCache;
+  return {
+    type: _actionTypes["default"].LOAD_FILE_STEP_SUCCESS,
+    fileName: fileName,
+    fileCache: fileCache
+  };
+}
+/**
+ * Trigger loading file error
+ * @memberof visStateActions
+ * @param  error
+ * @type {typeof import('./vis-state-actions').loadFilesErr}
+ * @returns action
+ * @public
+ */
+
+
+function loadFilesErr(fileName, error) {
+  return {
+    type: _actionTypes["default"].LOAD_FILES_ERR,
+    fileName: fileName,
+    error: error
+  };
+}
+/**
+ * Store features to state
+ * @memberof visStateActions
+ * @param features
+ * @type {typeof import('./vis-state-actions').setFeatures}
+ * @returns action
+ */
+
+
+function setFeatures(features) {
+  return {
+    type: _actionTypes["default"].SET_FEATURES,
+    features: features
+  };
+}
+/**
+ * It will apply the provide feature as filter to the given layer.
+ * If the given feature is already applied as filter to the layer, it will remove the layer from the filter
+ * @memberof visStateActions
+ * @param layer
+ * @param feature
+ * @type {typeof import('./vis-state-actions').setPolygonFilterLayer}
+ * @returns action
+ */
+
+
+function setPolygonFilterLayer(layer, feature) {
+  return {
+    type: _actionTypes["default"].SET_POLYGON_FILTER_LAYER,
+    layer: layer,
+    feature: feature
+  };
+}
+/**
+ * Set the current feature to be edited/deleted
+ * @memberof visStateActions
+ * @param feature
+ * @type {typeof import('./vis-state-actions').setSelectedFeature}
+ * @returns action
+ */
+
+
+function setSelectedFeature(feature) {
+  return {
+    type: _actionTypes["default"].SET_SELECTED_FEATURE,
+    feature: feature
+  };
+}
+/**
+ * Delete the given feature
+ * @memberof visStateActions
+ * @param feature
+ * @type {typeof import('./vis-state-actions').deleteFeature}
+ * @returns action
+ */
+
+
+function deleteFeature(feature) {
+  return {
+    type: _actionTypes["default"].DELETE_FEATURE,
+    feature: feature
+  };
+}
+/** Set the map mode
+ * @memberof visStateActions
+ * @param mode one of EDITOR_MODES
+ * @type {typeof import('./vis-state-actions').setEditorMode}
+ * @returns action
+ * @public
+ * @example
+ * import {setMapMode} from 'kepler.gl/actions';
+ * import {EDITOR_MODES} from 'kepler.gl/constants';
+ *
+ * this.props.dispatch(setMapMode(EDITOR_MODES.DRAW_POLYGON));
+ */
+
+
+function setEditorMode(mode) {
+  return {
+    type: _actionTypes["default"].SET_EDITOR_MODE,
+    mode: mode
+  };
+}
+/**
+ * Trigger CPU filter of selected dataset
+ * @memberof visStateActions
+ * @param dataId - single dataId or an array of dataIds
+ * @type {typeof import('./vis-state-actions').applyCPUFilter}
+ * @returns action
+ * @public
+ */
+
+
+function applyCPUFilter(dataId) {
+  return {
+    type: _actionTypes["default"].APPLY_CPU_FILTER,
+    dataId: dataId
+  };
+}
+/**
+ * Toggle editor layer visibility
+ * @memberof visStateActions
+ * @type {typeof import('./vis-state-actions').toggleEditorVisibility}
+ * @return action
+ */
+
+
+function toggleEditorVisibility() {
+  return {
+    type: _actionTypes["default"].TOGGLE_EDITOR_VISIBILITY
+  };
+}
+/**
+ * Process the next file batch
+ * @memberof visStateActions
+ * @param payload - batch payload
+ * @type {typeof import('./vis-state-actions').nextFileBatch}
+ * @return action
+ */
+
+
+function nextFileBatch(payload) {
+  return {
+    type: _actionTypes["default"].NEXT_FILE_BATCH,
+    payload: payload
+  };
+}
+/**
+ * Process the file content
+ * @memberof visStateActions
+ * @param payload - the file content
+ * @type {typeof import('./vis-state-actions').processFileContent}
+ * @return action
+ */
+
+
+function processFileContent(payload) {
+  return {
+    type: _actionTypes["default"].PROCESS_FILE_CONTENT,
+    payload: payload
+  };
+}
+/**
+ * Set layer animation time format and timezone
+ * @memberof visStateActions
+ * @param config - {timeFormat: string, timezone: string}
+ * @type {typeof import('./vis-state-actions').setLayerAnimationTimeConfig}
+ * @return action
+ */
+
+
+function setLayerAnimationTimeConfig(config) {
+  return {
+    type: _actionTypes["default"].SET_LAYER_ANIMATION_TIME_CONFIG,
+    config: config
+  };
+}
+/**
+ * Set Filter animation time format and timezone
+ * @memberof visStateActions
+ * @param idx
+ * @param config
+ * @type {typeof import('./vis-state-actions').setFilterAnimationTimeConfig}
+ * @return action
+ */
+
+
+function setFilterAnimationTimeConfig(idx, config) {
+  return {
+    type: _actionTypes["default"].SET_FILTER_ANIMATION_TIME_CONFIG,
+    idx: idx,
+    config: config
+  };
+}
+/**
+ * This declaration is needed to group actions in docs
+ */
+
+/**
+ * Actions handled mostly by `visState` reducer.
+ * They manage how data is processed, filtered and displayed on the map by operates on layers,
+ * filters and interaction settings.
+ *
+ * @public
+ */
+
+/* eslint-disable no-unused-vars */
+// @ts-ignore
+
+
+var visStateActions = null;
+/* eslint-enable no-unused-vars */
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/actions/vis-state-actions.js"],"names":["layerConfigChange","oldLayer","newConfig","type","ActionTypes","LAYER_CONFIG_CHANGE","layerTextLabelChange","idx","prop","value","LAYER_TEXT_LABEL_CHANGE","layerTypeChange","newType","LAYER_TYPE_CHANGE","layerVisualChannelConfigChange","channel","LAYER_VISUAL_CHANNEL_CHANGE","layerVisConfigChange","newVisConfig","LAYER_VIS_CONFIG_CHANGE","layerColorUIChange","LAYER_COLOR_UI_CHANGE","updateLayerBlending","mode","UPDATE_LAYER_BLENDING","interactionConfigChange","config","INTERACTION_CONFIG_CHANGE","setFilter","valueIndex","SET_FILTER","setFilterAnimationTime","SET_FILTER_ANIMATION_TIME","setFilterAnimationWindow","id","animationWindow","SET_FILTER_ANIMATION_WINDOW","addFilter","dataId","ADD_FILTER","addLayer","ADD_LAYER","reorderLayer","order","REORDER_LAYER","removeFilter","REMOVE_FILTER","removeLayer","REMOVE_LAYER","duplicateLayer","DUPLICATE_LAYER","removeDataset","REMOVE_DATASET","showDatasetTable","SHOW_DATASET_TABLE","sortTableColumn","column","SORT_TABLE_COLUMN","pinTableColumn","PIN_TABLE_COLUMN","copyTableColumn","COPY_TABLE_COLUMN","updateVisData","datasets","options","UPDATE_VIS_DATA","renameDataset","label","RENAME_DATASET","toggleFilterAnimation","TOGGLE_FILTER_ANIMATION","updateFilterAnimationSpeed","speed","UPDATE_FILTER_ANIMATION_SPEED","setLayerAnimationTime","SET_LAYER_ANIMATION_TIME","updateLayerAnimationSpeed","UPDATE_LAYER_ANIMATION_SPEED","toggleLayerAnimation","TOGGLE_LAYER_ANIMATION","toggleLayerAnimationControl","TOGGLE_LAYER_ANIMATION_CONTROL","enlargeFilter","ENLARGE_FILTER","toggleFilterFeature","TOGGLE_FILTER_FEATURE","onLayerHover","info","LAYER_HOVER","onLayerClick","LAYER_CLICK","onMapClick","MAP_CLICK","onMouseMove","evt","MOUSE_MOVE","toggleLayerForMap","mapIndex","layerId","TOGGLE_LAYER_FOR_MAP","setFilterPlot","newProp","SET_FILTER_PLOT","setMapInfo","SET_MAP_INFO","loadFiles","files","onFinish","LOAD_FILES","loadNextFile","LOAD_NEXT_FILE","loadFilesSuccess","result","LOAD_FILES_SUCCESS","loadFileStepSuccess","fileName","fileCache","LOAD_FILE_STEP_SUCCESS","loadFilesErr","error","LOAD_FILES_ERR","setFeatures","features","SET_FEATURES","setPolygonFilterLayer","layer","feature","SET_POLYGON_FILTER_LAYER","setSelectedFeature","SET_SELECTED_FEATURE","deleteFeature","DELETE_FEATURE","setEditorMode","SET_EDITOR_MODE","applyCPUFilter","APPLY_CPU_FILTER","toggleEditorVisibility","TOGGLE_EDITOR_VISIBILITY","nextFileBatch","payload","NEXT_FILE_BATCH","processFileContent","PROCESS_FILE_CONTENT","setLayerAnimationTimeConfig","SET_LAYER_ANIMATION_TIME_CONFIG","setFilterAnimationTimeConfig","SET_FILTER_ANIMATION_TIME_CONFIG","visStateActions"],"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\n// vis-state-reducer\nimport ActionTypes from 'constants/action-types';\n\n/**\n * Update layer base config: dataId, label, column, isVisible\n * @param oldLayer - layer to be updated\n * @param newConfig - new config to be merged with old config\n * @returns action\n * @type {typeof import('./vis-state-actions').layerConfigChange}\n * @public\n */\nexport function layerConfigChange(oldLayer, newConfig) {\n  return {\n    type: ActionTypes.LAYER_CONFIG_CHANGE,\n    oldLayer,\n    newConfig\n  };\n}\n\n/**\n * Update layer text label\n * @param oldLayer - layer to be updated\n * @param idx -`idx` of text label to be updated\n * @param prop - `prop` of text label, e,g, `anchor`, `alignment`, `color`, `size`, `field`\n * @param value - new value\n * @returns action\n * @type {typeof import('./vis-state-actions').layerTextLabelChange}\n * @public\n */\nexport function layerTextLabelChange(oldLayer, idx, prop, value) {\n  return {\n    type: ActionTypes.LAYER_TEXT_LABEL_CHANGE,\n    oldLayer,\n    idx,\n    prop,\n    value\n  };\n}\n\n/**\n * Update layer type. Previews layer config will be copied if applicable.\n * @param oldLayer - layer to be updated\n * @param newType - new type\n * @returns action\n * @type {typeof import('./vis-state-actions').layerTypeChange}\n * @public\n */\nexport function layerTypeChange(oldLayer, newType) {\n  return {\n    type: ActionTypes.LAYER_TYPE_CHANGE,\n    oldLayer,\n    newType\n  };\n}\n\n/**\n * Update layer visual channel\n * @memberof visStateActions\n * @param oldLayer - layer to be updated\n * @param newConfig - new visual channel config\n * @param channel - channel to be updated\n * @returns action\n * @type {typeof import('./vis-state-actions').layerVisualChannelConfigChange}\n * @public\n */\nexport function layerVisualChannelConfigChange(oldLayer, newConfig, channel) {\n  return {\n    type: ActionTypes.LAYER_VISUAL_CHANNEL_CHANGE,\n    oldLayer,\n    newConfig,\n    channel\n  };\n}\n\n/**\n * Update layer `visConfig`\n * @memberof visStateActions\n * @param oldLayer - layer to be updated\n * @param newVisConfig - new visConfig as a key value map: e.g. `{opacity: 0.8}`\n * @returns action\n * @type {typeof import('./vis-state-actions').layerVisConfigChange}\n * @public\n */\nexport function layerVisConfigChange(oldLayer, newVisConfig) {\n  return {\n    type: ActionTypes.LAYER_VIS_CONFIG_CHANGE,\n    oldLayer,\n    newVisConfig\n  };\n}\n\n/**\n * Set the color palette ui for layer color\n * @memberOf visStateActions\n * @param oldLayer - layer to be updated\n * @param prop - which color prop\n * @param newConfig - to be merged\n * @returns action\n * @type {typeof import('./vis-state-actions').layerColorUIChange}\n * @public\n */\nexport function layerColorUIChange(oldLayer, prop, newConfig) {\n  return {\n    type: ActionTypes.LAYER_COLOR_UI_CHANGE,\n    oldLayer,\n    prop,\n    newConfig\n  };\n}\n\n/**\n * Update layer blending mode\n * @memberof visStateActions\n * @param mode one of `additive`, `normal` and `subtractive`\n * @returns action\n * @type {typeof import('./vis-state-actions').updateLayerBlending}\n * @public\n */\nexport function updateLayerBlending(mode) {\n  return {\n    type: ActionTypes.UPDATE_LAYER_BLENDING,\n    mode\n  };\n}\n\n/**\n * Update `interactionConfig`\n * @memberof visStateActions\n * @param config - new config as key value map: `{tooltip: {enabled: true}}`\n * @returns action\n * @type {typeof import('./vis-state-actions').interactionConfigChange}\n * @public\n */\nexport function interactionConfigChange(config) {\n  return {\n    type: ActionTypes.INTERACTION_CONFIG_CHANGE,\n    config\n  };\n}\n\n/**\n * Update filter property\n * @memberof visStateActions\n * @param idx -`idx` of filter to be updated\n * @param prop - `prop` of filter, e,g, `dataId`, `name`, `value`\n * @param value - new value\n * @param valueIndex - dataId index\n * @returns action\n * @type {typeof import('./vis-state-actions').setFilter}\n * @public\n */\nexport function setFilter(idx, prop, value, valueIndex) {\n  return {\n    type: ActionTypes.SET_FILTER,\n    idx,\n    prop,\n    value,\n    valueIndex\n  };\n}\n\n/**\n * Same as Update filter\n * @memberof visStateActions\n * @param idx -`idx` of filter to be updated\n * @param prop - `prop` of filter, e,g, `dataId`, `name`, `value`\n * @param value - new value\n * @param valueIndex - dataId index\n * @returns action\n * @type {typeof import('./vis-state-actions').setFilterAnimationTime}\n * @public\n */\nexport function setFilterAnimationTime(idx, prop, value, valueIndex) {\n  return {\n    type: ActionTypes.SET_FILTER_ANIMATION_TIME,\n    idx,\n    prop,\n    value,\n    valueIndex\n  };\n}\n\n/**\n * Same as Update filter\n * @memberof visStateActions\n * @type {typeof import('./vis-state-actions').setFilterAnimationWindow}\n * @public\n */\nexport function setFilterAnimationWindow({id, animationWindow}) {\n  return {\n    type: ActionTypes.SET_FILTER_ANIMATION_WINDOW,\n    id,\n    animationWindow\n  };\n}\n/**\n * Add a new filter\n * @memberof visStateActions\n * @param dataId - dataset `id` this new filter is associated with\n * @returns action\n * @type {typeof import('./vis-state-actions').addFilter}\n * @public\n */\nexport function addFilter(dataId) {\n  return {\n    type: ActionTypes.ADD_FILTER,\n    dataId\n  };\n}\n\n/**\n * Add a new layer\n * @memberof visStateActions\n * @param config - new layer config\n * @returns action\n * @type {typeof import('./vis-state-actions').addLayer}\n * @public\n */\nexport function addLayer(config) {\n  return {\n    type: ActionTypes.ADD_LAYER,\n    config\n  };\n}\n\n/**\n * Reorder layer, order is an array of layer indexes, index 0 will be the one at the bottom\n * @memberof visStateActions\n * @param order an array of layer indexes\n * @returns action\n * @type {typeof import('./vis-state-actions').reorderLayer}\n * @public\n * @example\n *\n * // bring `layers[1]` below `layers[0]`, the sequence layers will be rendered is `1`, `0`, `2`, `3`.\n * // `1` will be at the bottom, `3` will be at the top.\n * this.props.dispatch(reorderLayer([1, 0, 2, 3]));\n */\nexport function reorderLayer(order) {\n  return {\n    type: ActionTypes.REORDER_LAYER,\n    order\n  };\n}\n\n/**\n * Remove a filter from `visState.filters`, once a filter is removed, data will be re-filtered and layer will be updated\n * @memberof visStateActions\n * @param idx idx of filter to be removed\n * @returns action\n * @type {typeof import('./vis-state-actions').removeFilter}\n * @public\n */\nexport function removeFilter(idx) {\n  return {\n    type: ActionTypes.REMOVE_FILTER,\n    idx\n  };\n}\n\n/**\n * Remove a layer\n * @memberof visStateActions\n * @param idx idx of layer to be removed\n * @returns action\n * @type {typeof import('./vis-state-actions').removeLayer}\n * @public\n */\nexport function removeLayer(idx) {\n  return {\n    type: ActionTypes.REMOVE_LAYER,\n    idx\n  };\n}\n\n/**\n * Duplicate a layer\n * @memberof visStateActions\n * @param idx idx of layer to be duplicated\n * @returns action\n * @type {typeof import('./vis-state-actions').duplicateLayer}\n * @public\n */\nexport function duplicateLayer(idx) {\n  return {\n    type: ActionTypes.DUPLICATE_LAYER,\n    idx\n  };\n}\n\n/**\n * Remove a dataset and all layers, filters, tooltip configs that based on it\n * @memberof visStateActions\n * @param dataId dataset id\n * @returns action\n * @type {typeof import('./vis-state-actions').removeDataset}\n * @public\n */\nexport function removeDataset(dataId) {\n  return {\n    type: ActionTypes.REMOVE_DATASET,\n    dataId\n  };\n}\n\n/**\n * Display dataset table in a modal\n * @memberof visStateActions\n * @param dataId dataset id to show in table\n * @returns action\n * @type {typeof import('./vis-state-actions').showDatasetTable}\n * @public\n */\nexport function showDatasetTable(dataId) {\n  return {\n    type: ActionTypes.SHOW_DATASET_TABLE,\n    dataId\n  };\n}\n\n/**\n * Sort dataset column, for table display\n * @memberof visStateActions\n * @param dataId\n * @param column\n * @param mode\n * @returns action\n * @type {typeof import('./vis-state-actions').sortTableColumn}\n * @public\n */\nexport function sortTableColumn(dataId, column, mode) {\n  return {\n    type: ActionTypes.SORT_TABLE_COLUMN,\n    dataId,\n    column,\n    mode\n  };\n}\n\n/**\n * Pin dataset column, for table display\n * @param dataId\n * @param column\n * @returns action\n * @type {typeof import('./vis-state-actions').pinTableColumn}\n * @public\n */\nexport function pinTableColumn(dataId, column) {\n  return {\n    type: ActionTypes.PIN_TABLE_COLUMN,\n    dataId,\n    column\n  };\n}\n\n/**\n * Copy column, for table display\n * @param dataId\n * @param column\n * @returns action\n * @type {typeof import('./vis-state-actions').copyTableColumn}\n * @public\n */\nexport function copyTableColumn(dataId, column) {\n  return {\n    type: ActionTypes.COPY_TABLE_COLUMN,\n    dataId,\n    column\n  };\n}\n\n// * @param dataset.info -info of a dataset\n// * @param dataset.info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.\n// * @param dataset.info.label - A display name of this dataset\n// * @param dataset.data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`\n// * @param dataset.data.fields - ***required** Array of fields,\n// * @param dataset.data.fields.name - ***required** Name of the field,\n// * @param dataset.data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`\n/**\n * Add new dataset to `visState`, with option to load a map config along with the datasets\n * @memberof visStateActions\n * @param datasets - ***required** datasets can be a dataset or an array of datasets\n * Each dataset object needs to have `info` and `data` property.\n * @param {object} options\n * @param options.centerMap `default: true` if `centerMap` is set to `true` kepler.gl will\n * place the map view within the data points boundaries\n * @param options.readOnly `default: false` if `readOnly` is set to `true`\n * the left setting panel will be hidden\n * @param config this object will contain the full kepler.gl instance configuration {mapState, mapStyle, visState}\n * @returns action\n * @type {typeof import('./vis-state-actions').updateVisData}\n * @public\n */\nexport function updateVisData(datasets, options, config) {\n  return {\n    type: ActionTypes.UPDATE_VIS_DATA,\n    datasets,\n    options,\n    config\n  };\n}\n\n/**\n * Rename an existing dataset in `visState`\n * @memberof visStateActions\n * @param dataId - ***required** Id of the dataset to update\n * @param label - ***required** New name for the dataset\n * @returns action\n * @type {typeof import('./vis-state-actions').renameDataset}\n * @public\n */\nexport function renameDataset(dataId, label) {\n  return {\n    type: ActionTypes.RENAME_DATASET,\n    dataId,\n    label\n  };\n}\n\n/**\n * Start and end filter animation\n * @memberof visStateActions\n * @param {Number} idx of filter\n * @type {typeof import('./vis-state-actions').toggleFilterAnimation}\n * @returns action\n * @public\n */\nexport function toggleFilterAnimation(idx) {\n  return {\n    type: ActionTypes.TOGGLE_FILTER_ANIMATION,\n    idx\n  };\n}\n\n/**\n * Change filter animation speed\n * @memberof visStateActions\n * @param idx -  `idx` of filter\n * @param speed - `speed` to change it to. `speed` is a multiplier\n * @type {typeof import('./vis-state-actions').updateFilterAnimationSpeed}\n * @returns action\n * @public\n */\nexport function updateFilterAnimationSpeed(idx, speed) {\n  return {\n    type: ActionTypes.UPDATE_FILTER_ANIMATION_SPEED,\n    idx,\n    speed\n  };\n}\n\n/**\n * Reset animation\n * @memberof visStateActions\n * @param value -  Current value of the slider\n * @type {typeof import('./vis-state-actions').setLayerAnimationTime}\n * @returns action\n * @public\n */\nexport function setLayerAnimationTime(value) {\n  return {\n    type: ActionTypes.SET_LAYER_ANIMATION_TIME,\n    value\n  };\n}\n\n/**\n * update trip layer animation speed\n * @memberof visStateActions\n * @param speed - `speed` to change it to. `speed` is a multiplier\n * @type {typeof import('./vis-state-actions').updateLayerAnimationSpeed}\n * @returns action\n * @public\n */\nexport function updateLayerAnimationSpeed(speed) {\n  return {\n    type: ActionTypes.UPDATE_LAYER_ANIMATION_SPEED,\n    speed\n  };\n}\n\n/**\n * start end end layer animation\n * @memberof visStateActions\n * @type {typeof import('./vis-state-actions').toggleLayerAnimation}\n * @returns action\n * @public\n */\nexport function toggleLayerAnimation() {\n  return {\n    type: ActionTypes.TOGGLE_LAYER_ANIMATION\n  };\n}\n\n/**\n * hide and show layer animation control\n * @memberof visStateActions\n * @type {typeof import('./vis-state-actions').toggleLayerAnimationControl}\n * @returns action\n * @public\n */\nexport function toggleLayerAnimationControl() {\n  return {\n    type: ActionTypes.TOGGLE_LAYER_ANIMATION_CONTROL\n  };\n}\n\n/**\n * Show larger time filter at bottom for time playback (apply to time filter only)\n * @memberof visStateActions\n * @param idx - index of filter to enlarge\n * @type {typeof import('./vis-state-actions').enlargeFilter}\n * @returns action\n * @public\n */\nexport function enlargeFilter(idx) {\n  return {\n    type: ActionTypes.ENLARGE_FILTER,\n    idx\n  };\n}\n\n/**\n * Show/hide filter feature on map\n * @memberof visStateActions\n * @param idx - index of filter feature to show/hide\n * @type {typeof import('./vis-state-actions').toggleFilterFeature}\n * @return action\n */\nexport function toggleFilterFeature(idx) {\n  return {\n    type: ActionTypes.TOGGLE_FILTER_FEATURE,\n    idx\n  };\n}\n\n/**\n * Trigger layer hover event with hovered object\n * @memberof visStateActions\n * @param info - Object hovered, returned by deck.gl\n * @type {typeof import('./vis-state-actions').onLayerHover}\n * @returns action\n * @public\n */\nexport function onLayerHover(info) {\n  return {\n    type: ActionTypes.LAYER_HOVER,\n    info\n  };\n}\n\n/**\n * Trigger layer click event with clicked object\n * @memberof visStateActions\n * @param info - Object clicked, returned by deck.gl\n * @type {typeof import('./vis-state-actions').onLayerClick}\n * @returns action\n * @public\n */\nexport function onLayerClick(info) {\n  return {\n    type: ActionTypes.LAYER_CLICK,\n    info\n  };\n}\n\n/**\n * Trigger map click event, unselect clicked object\n * @memberof visStateActions\n * @type {typeof import('./vis-state-actions').onMapClick}\n * @returns action\n * @public\n */\nexport function onMapClick() {\n  return {\n    type: ActionTypes.MAP_CLICK\n  };\n}\n\n/**\n * Trigger map mouse moveevent, payload would be\n * React-map-gl PointerEvent\n * https://uber.github.io/react-map-gl/#/documentation/api-reference/pointer-event\n *\n * @memberof visStateActions\n * @param evt - PointerEvent\n * @type {typeof import('./vis-state-actions').onMouseMove}\n * @returns action\n * @public\n */\nexport function onMouseMove(evt) {\n  return {\n    type: ActionTypes.MOUSE_MOVE,\n    evt\n  };\n}\n\n/**\n * Toggle visibility of a layer in a split map\n * @memberof visStateActions\n * @param mapIndex - index of the split map\n * @param layerId - id of the layer\n * @type {typeof import('./vis-state-actions').toggleLayerForMap}\n * @returns action\n * @public\n */\nexport function toggleLayerForMap(mapIndex, layerId) {\n  return {\n    type: ActionTypes.TOGGLE_LAYER_FOR_MAP,\n    mapIndex,\n    layerId\n  };\n}\n\n/**\n * Set the property of a filter plot\n * @memberof visStateActions\n * @param idx\n * @param newProp key value mapping of new prop `{yAxis: 'histogram'}`\n * @param valueIndex dataId index\n * @type {typeof import('./vis-state-actions').setFilterPlot}\n * @returns action\n * @public\n */\nexport function setFilterPlot(idx, newProp, valueIndex) {\n  return {\n    type: ActionTypes.SET_FILTER_PLOT,\n    idx,\n    newProp,\n    valueIndex\n  };\n}\n\n/**\n * Set the property of a filter plot\n * @memberof visStateActions\n * @param info\n * @type {typeof import('./vis-state-actions').setMapInfo}\n * @returns action\n * @public\n */\nexport function setMapInfo(info) {\n  return {\n    type: ActionTypes.SET_MAP_INFO,\n    info\n  };\n}\n\n/**\n * Trigger file loading dispatch `addDataToMap` if succeed, or `loadFilesErr` if failed\n * @memberof visStateActions\n * @param files array of fileblob\n * @type {typeof import('./vis-state-actions').loadFiles}\n * @returns action\n * @public\n */\nexport function loadFiles(files, onFinish) {\n  return {\n    type: ActionTypes.LOAD_FILES,\n    files,\n    onFinish\n  };\n}\n\n/**\n * Called with next file to load\n * @memberof visStateActions\n * @type {typeof import('./vis-state-actions').loadNextFile}\n * @returns action\n * @public\n */\nexport function loadNextFile() {\n  return {\n    type: ActionTypes.LOAD_NEXT_FILE\n  };\n}\n\n/**\n * called when all files are processed and loaded\n * @memberof visStateActions\n * @param result\n * @type {typeof import('./vis-state-actions').loadFilesSuccess}\n * @returns action\n */\nexport function loadFilesSuccess(result) {\n  return {\n    type: ActionTypes.LOAD_FILES_SUCCESS,\n    result\n  };\n}\n\n/**\n * called when successfully loaded one file, ready to move on to the next one\n * @memberof visStateActions\n * @param result\n * @type {typeof import('./vis-state-actions').loadFileStepSuccess}\n * @returns action\n */\nexport function loadFileStepSuccess({fileName, fileCache}) {\n  return {\n    type: ActionTypes.LOAD_FILE_STEP_SUCCESS,\n    fileName,\n    fileCache\n  };\n}\n\n/**\n * Trigger loading file error\n * @memberof visStateActions\n * @param  error\n * @type {typeof import('./vis-state-actions').loadFilesErr}\n * @returns action\n * @public\n */\nexport function loadFilesErr(fileName, error) {\n  return {\n    type: ActionTypes.LOAD_FILES_ERR,\n    fileName,\n    error\n  };\n}\n\n/**\n * Store features to state\n * @memberof visStateActions\n * @param features\n * @type {typeof import('./vis-state-actions').setFeatures}\n * @returns action\n */\nexport function setFeatures(features) {\n  return {\n    type: ActionTypes.SET_FEATURES,\n    features\n  };\n}\n\n/**\n * It will apply the provide feature as filter to the given layer.\n * If the given feature is already applied as filter to the layer, it will remove the layer from the filter\n * @memberof visStateActions\n * @param layer\n * @param feature\n * @type {typeof import('./vis-state-actions').setPolygonFilterLayer}\n * @returns action\n */\nexport function setPolygonFilterLayer(layer, feature) {\n  return {\n    type: ActionTypes.SET_POLYGON_FILTER_LAYER,\n    layer,\n    feature\n  };\n}\n\n/**\n * Set the current feature to be edited/deleted\n * @memberof visStateActions\n * @param feature\n * @type {typeof import('./vis-state-actions').setSelectedFeature}\n * @returns action\n */\nexport function setSelectedFeature(feature) {\n  return {\n    type: ActionTypes.SET_SELECTED_FEATURE,\n    feature\n  };\n}\n\n/**\n * Delete the given feature\n * @memberof visStateActions\n * @param feature\n * @type {typeof import('./vis-state-actions').deleteFeature}\n * @returns action\n */\nexport function deleteFeature(feature) {\n  return {\n    type: ActionTypes.DELETE_FEATURE,\n    feature\n  };\n}\n\n/** Set the map mode\n * @memberof visStateActions\n * @param mode one of EDITOR_MODES\n * @type {typeof import('./vis-state-actions').setEditorMode}\n * @returns action\n * @public\n * @example\n * import {setMapMode} from 'kepler.gl/actions';\n * import {EDITOR_MODES} from 'kepler.gl/constants';\n *\n * this.props.dispatch(setMapMode(EDITOR_MODES.DRAW_POLYGON));\n */\nexport function setEditorMode(mode) {\n  return {\n    type: ActionTypes.SET_EDITOR_MODE,\n    mode\n  };\n}\n\n/**\n * Trigger CPU filter of selected dataset\n * @memberof visStateActions\n * @param dataId - single dataId or an array of dataIds\n * @type {typeof import('./vis-state-actions').applyCPUFilter}\n * @returns action\n * @public\n */\nexport function applyCPUFilter(dataId) {\n  return {\n    type: ActionTypes.APPLY_CPU_FILTER,\n    dataId\n  };\n}\n\n/**\n * Toggle editor layer visibility\n * @memberof visStateActions\n * @type {typeof import('./vis-state-actions').toggleEditorVisibility}\n * @return action\n */\nexport function toggleEditorVisibility() {\n  return {\n    type: ActionTypes.TOGGLE_EDITOR_VISIBILITY\n  };\n}\n\n/**\n * Process the next file batch\n * @memberof visStateActions\n * @param payload - batch payload\n * @type {typeof import('./vis-state-actions').nextFileBatch}\n * @return action\n */\nexport function nextFileBatch(payload) {\n  return {\n    type: ActionTypes.NEXT_FILE_BATCH,\n    payload\n  };\n}\n\n/**\n * Process the file content\n * @memberof visStateActions\n * @param payload - the file content\n * @type {typeof import('./vis-state-actions').processFileContent}\n * @return action\n */\nexport function processFileContent(payload) {\n  return {\n    type: ActionTypes.PROCESS_FILE_CONTENT,\n    payload\n  };\n}\n\n/**\n * Set layer animation time format and timezone\n * @memberof visStateActions\n * @param config - {timeFormat: string, timezone: string}\n * @type {typeof import('./vis-state-actions').setLayerAnimationTimeConfig}\n * @return action\n */\nexport function setLayerAnimationTimeConfig(config) {\n  return {\n    type: ActionTypes.SET_LAYER_ANIMATION_TIME_CONFIG,\n    config\n  };\n}\n\n/**\n * Set Filter animation time format and timezone\n * @memberof visStateActions\n * @param idx\n * @param config\n * @type {typeof import('./vis-state-actions').setFilterAnimationTimeConfig}\n * @return action\n */\nexport function setFilterAnimationTimeConfig(idx, config) {\n  return {\n    type: ActionTypes.SET_FILTER_ANIMATION_TIME_CONFIG,\n    idx,\n    config\n  };\n}\n\n/**\n * This declaration is needed to group actions in docs\n */\n/**\n * Actions handled mostly by `visState` reducer.\n * They manage how data is processed, filtered and displayed on the map by operates on layers,\n * filters and interaction settings.\n *\n * @public\n */\n/* eslint-disable no-unused-vars */\n// @ts-ignore\nconst visStateActions = null;\n/* eslint-enable no-unused-vars */\n"]}