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

package/src/processors/file-handler.d.ts

@@ -0,0 +1,46 @@
+// Copyright (c) 2020 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 {AddDataToMapPayload} from 'actions/actions';
+
+export type FileCacheItem = {
+  data: any;
+  info: {
+    label: string;
+    format: string;
+  };
+};
+
+export function readFileInBatches(payload: {
+  file: File;
+  fileCache: FileCacheItem[];
+  loaders: LoaderObject;
+  loadOptions: object;
+}): AsyncGenerator;
+
+export function processFileData(payload: {
+  content: any;
+  fileCache: FileCacheItem[];
+}): Promise<FileCacheItem[]>;
+
+export function filesToDataPayload(fileCache: FileCacheItem[]): AddDataToMapPayload[];
+
+export function readBatch(asyncIterator, fileName): AsyncIterable<any>;
+export function isKeplerGlMap(obj: any): Boolean;

package/src/processors/file-handler.js

@@ -0,0 +1,220 @@
+// 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 {parseInBatches} from '@loaders.gl/core';
+import {JSONLoader, _JSONPath} from '@loaders.gl/json';
+import {CSVLoader} from '@loaders.gl/csv';
+import {processGeojson, processKeplerglJSON, processRowObject} from './data-processor';
+import {isPlainObject, generateHashId} from 'utils/utils';
+import {DATASET_FORMATS} from 'constants/default-settings';
+
+const BATCH_TYPE = {
+  METADATA: 'metadata',
+  PARTIAL_RESULT: 'partial-result',
+  FINAL_RESULT: 'final-result'
+};
+
+const CSV_LOADER_OPTIONS = {
+  batchSize: 4000, // Auto de tect number of rows per batch (network batch size)
+  rowFormat: 'object',
+  dynamicTyping: false // not working for now
+};
+
+const JSON_LOADER_OPTIONS = {
+  // instruct loaders.gl on what json paths to stream
+  jsonpaths: [
+    '$', // JSON Row array
+    '$.features', // GeoJSON
+    '$.datasets' // KeplerGL JSON
+  ]
+};
+
+export function isGeoJson(json) {
+  // json can be feature collection
+  // or single feature
+  return isPlainObject(json) && (isFeature(json) || isFeatureCollection(json));
+}
+
+export function isFeature(json) {
+  return json.type === 'Feature' && json.geometry;
+}
+
+export function isFeatureCollection(json) {
+  return json.type === 'FeatureCollection' && json.features;
+}
+
+export function isRowObject(json) {
+  return Array.isArray(json) && isPlainObject(json[0]);
+}
+
+export function isKeplerGlMap(json) {
+  return Boolean(
+    isPlainObject(json) &&
+      json.datasets &&
+      json.config &&
+      json.info &&
+      json.info.app === 'kepler.gl'
+  );
+}
+
+export async function* makeProgressIterator(asyncIterator, info) {
+  let rowCount = 0;
+
+  for await (const batch of asyncIterator) {
+    const rowCountInBatch = (batch.data && batch.data.length) || 0;
+    rowCount += rowCountInBatch;
+    const percent = Number.isFinite(batch.bytesUsed) ? batch.bytesUsed / info.size : null;
+
+    // Update progress object
+    const progress = {
+      rowCount,
+      rowCountInBatch,
+      // @ts-ignore
+      ...(Number.isFinite(percent) ? {percent} : {})
+    };
+
+    yield {...batch, progress};
+  }
+}
+
+// eslint-disable-next-line complexity
+export async function* readBatch(asyncIterator, fileName) {
+  let result = null;
+  const batches = [];
+
+  for await (const batch of asyncIterator) {
+    // Last batch will have this special type and will provide all the root
+    // properties of the parsed document.
+    // Only json parse will have `FINAL_RESULT`
+    if (batch.batchType === BATCH_TYPE.FINAL_RESULT) {
+      if (batch.container) {
+        result = {...batch.container};
+      }
+      // Set the streamed data correctly is Batch json path is set
+      // and the path streamed is not the top level object (jsonpath = '$')
+      if (batch.jsonpath && batch.jsonpath.length > 1) {
+        const streamingPath = new _JSONPath(batch.jsonpath);
+        streamingPath.setFieldAtPath(result, batches);
+      } else if (batch.jsonpath && batch.jsonpath.length === 1) {
+        // The streamed object is a ROW JSON-batch (jsonpath = '$')
+        // row objects
+        result = batches;
+      }
+    } else {
+      for (let i = 0; i < batch.data.length; i++) {
+        batches.push(batch.data[i]);
+      }
+    }
+
+    yield {
+      ...batch,
+      ...(batch.schema ? {headers: Object.keys(batch.schema)} : {}),
+      fileName,
+      // if dataset is CSV, data is set to the raw batches
+      data: result ? result : batches
+    };
+  }
+}
+
+export async function readFileInBatches({file, fileCache = [], loaders = [], loadOptions = {}}) {
+  loaders = [JSONLoader, CSVLoader, ...loaders];
+  loadOptions = {
+    csv: CSV_LOADER_OPTIONS,
+    json: JSON_LOADER_OPTIONS,
+    metadata: true,
+    ...loadOptions
+  };
+
+  const batchIterator = await parseInBatches(file, loaders, loadOptions);
+  const progressIterator = makeProgressIterator(batchIterator, {size: file.size});
+
+  return readBatch(progressIterator, file.name);
+}
+
+export function processFileData({content, fileCache}) {
+  return new Promise((resolve, reject) => {
+    const {data} = content;
+
+    let format;
+    let processor;
+    if (isKeplerGlMap(data)) {
+      format = DATASET_FORMATS.keplergl;
+      processor = processKeplerglJSON;
+    } else if (isRowObject(data)) {
+      format = DATASET_FORMATS.row;
+      processor = processRowObject;
+    } else if (isGeoJson(data)) {
+      format = DATASET_FORMATS.geojson;
+      processor = processGeojson;
+    }
+
+    if (format && processor) {
+      const result = processor(data);
+
+      resolve([
+        ...fileCache,
+        {
+          data: result,
+          info: {
+            label: content.fileName,
+            format
+          }
+        }
+      ]);
+    }
+
+    reject('Unknow File Format');
+  });
+}
+
+export function filesToDataPayload(fileCache) {
+  // seperate out files which could be a single datasets. or a keplergl map json
+  const collection = fileCache.reduce(
+    (accu, file) => {
+      const {data, info = {}} = file;
+      const {format} = info;
+      if (format === DATASET_FORMATS.keplergl) {
+        // if file contains a single kepler map dataset & config
+        accu.keplerMaps.push({
+          ...data,
+          options: {
+            centerMap: !(data.config && data.config.mapState)
+          }
+        });
+      } else if (DATASET_FORMATS[format]) {
+        // if file contains only data
+        const newDataset = {
+          data,
+          info: {
+            id: info.id || generateHashId(4),
+            ...info
+          }
+        };
+        accu.datasets.push(newDataset);
+      }
+      return accu;
+    },
+    {datasets: [], keplerMaps: []}
+  );
+
+  // add kepler map first with config
+  // add datasets later in one add data call
+  return collection.keplerMaps.concat({datasets: collection.datasets});
+}

package/src/processors/index.js

@@ -0,0 +1,44 @@
+// 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.
+
+// Data Processor
+export {
+  formatCsv,
+  processGeojson,
+  processCsvData,
+  processRowObject,
+  processKeplerglJSON,
+  processKeplerglDataset,
+  analyzerTypeToFieldType,
+  getFieldsFromData,
+  parseRowsByFields,
+  parseCsvRowsByFieldType
+} from './data-processor';
+
+// File Handlers
+export {
+  readFileInBatches,
+  processFileData,
+  filesToDataPayload,
+  isKeplerGlMap,
+  readBatch
+} from './file-handler';
+
+export {Processors as default} from './data-processor';

package/src/reducers/combined-updaters.d.ts

@@ -0,0 +1,26 @@
+import {VisState} from './vis-state-updaters';
+import {MapState} from './map-state-updaters';
+import {UiState} from './ui-state-updaters';
+import {MapStyle} from './map-style-updaters';
+import {ProviderState} from './provider-state-updaters';
+import {AddDataToMapPayload} from 'actions/actions';
+import {FileCacheItem} from 'processors/file-handler';
+import {loadFilesSuccessUpdaterAction} from 'actions/vis-state-actions';
+
+export type KeplerGlState = {
+  visState: VisState;
+  mapState: MapState;
+  mapStyle: MapStyle;
+  uiState: UiState;
+  providerState: ProviderState;
+};
+
+export function addDataToMapUpdater(
+  state: KeplerGlState,
+  action: {payload: AddDataToMapPayload}
+): KeplerGlState;
+
+export function loadFilesSuccessUpdater(
+  state: KeplerGlState,
+  action: loadFilesSuccessUpdaterAction
+): KeplerGlState;

package/src/reducers/combined-updaters.js

@@ -0,0 +1,198 @@
+// 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 {
+  toggleModalUpdater,
+  loadFilesSuccessUpdater as uiStateLoadFilesSuccessUpdater
+} from './ui-state-updaters';
+import {
+  updateVisDataUpdater as visStateUpdateVisDataUpdater,
+  setMapInfoUpdater
+} from './vis-state-updaters';
+import {receiveMapConfigUpdater as stateMapConfigUpdater} from './map-state-updaters';
+import {receiveMapConfigUpdater as styleMapConfigUpdater} from './map-style-updaters';
+import {findMapBounds} from 'utils/data-utils';
+import {isPlainObject} from 'utils/utils';
+import {filesToDataPayload} from 'processors/file-handler';
+import {payload_, apply_, with_, if_, compose_, merge_, pick_} from './composer-helpers';
+
+// compose action to apply result multiple reducers, with the output of one
+
+/**
+ * Some actions will affect the entire kepler.lg instance state.
+ * The updaters for these actions is exported as `combinedUpdaters`. These updater take the entire instance state
+ * as the first argument. Read more about [Using updaters](../advanced-usage/using-updaters.md)
+ * @public
+ * @example
+ *
+ * import keplerGlReducer, {combinedUpdaters} from 'kepler.gl/reducers';
+ * // Root Reducer
+ * const reducers = combineReducers({
+ *  keplerGl: keplerGlReducer,
+ *  app: appReducer
+ * });
+ *
+ * const composedReducer = (state, action) => {
+ *  switch (action.type) {
+ *    // add data to map after receiving data from remote sources
+ *    case 'LOAD_REMOTE_RESOURCE_SUCCESS':
+ *      return {
+ *        ...state,
+ *        keplerGl: {
+ *          ...state.keplerGl,
+ *          // pass in kepler.gl instance state to combinedUpdaters
+ *          map:  combinedUpdaters.addDataToMapUpdater(
+ *           state.keplerGl.map,
+ *           {
+ *             payload: {
+ *               datasets: action.datasets,
+ *               options: {readOnly: true},
+ *               config: action.config
+ *              }
+ *            }
+ *          )
+ *        }
+ *      };
+ *  }
+ *  return reducers(state, action);
+ * };
+ *
+ * export default composedReducer;
+ */
+
+/* eslint-disable no-unused-vars */
+// @ts-ignore
+const combinedUpdaters = null;
+/* eslint-enable no-unused-vars */
+
+export const isValidConfig = config =>
+  isPlainObject(config) && isPlainObject(config.config) && config.version;
+
+export const defaultAddDataToMapOptions = {
+  centerMap: true,
+  keepExistingConfig: false,
+  autoCreateLayers: true
+};
+
+/**
+ * Combine data and full configuration update in a single action
+ *
+ * @memberof combinedUpdaters
+ * @param {Object} state kepler.gl instance state, containing all subreducer state
+ * @param {Object} action
+ * @param {Object} action.payload `{datasets, options, config}`
+ * @param action.payload.datasets - ***required** datasets can be a dataset or an array of datasets
+ * Each dataset object needs to have `info` and `data` property.
+ * @param [action.payload.options] option object `{centerMap: true}`
+ * @param [action.payload.config] map config
+ * @param [action.payload.info] map info contains title and description
+ * @returns nextState
+ *
+ * @typedef {Object} Dataset
+ * @property info -info of a dataset
+ * @property info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.
+ * @property info.label - A display name of this dataset
+ * @property data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`
+ * @property data.fields - ***required** Array of fields,
+ * @property data.fields.name - ***required** Name of the field,
+ * @property data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`
+ *
+ * @type {typeof import('./combined-updaters').addDataToMapUpdater}
+ * @public
+ */
+export const addDataToMapUpdater = (state, {payload}) => {
+  const {datasets, config, info} = payload;
+
+  const options = {
+    ...defaultAddDataToMapOptions,
+    ...payload.options
+  };
+
+  let parsedConfig = config;
+
+  if (isValidConfig(config)) {
+    // if passed in saved config
+    parsedConfig = state.visState.schema.parseSavedConfig(config);
+  }
+  const oldLayers = state.visState.layers;
+  const filterNewlyAddedLayers = layers => layers.filter(nl => !oldLayers.find(ol => ol === nl));
+
+  // Returns undefined if not found, to make typescript happy
+  const findMapBoundsIfCentered = layers => {
+    const bounds = options.centerMap && findMapBounds(layers);
+    return bounds ? bounds : undefined;
+  };
+
+  return compose_([
+    pick_('visState')(
+      apply_(visStateUpdateVisDataUpdater, {
+        datasets,
+        options,
+        config: parsedConfig
+      })
+    ),
+
+    if_(info, pick_('visState')(apply_(setMapInfoUpdater, {info}))),
+
+    with_(({visState}) =>
+      pick_('mapState')(
+        apply_(
+          stateMapConfigUpdater,
+          payload_({
+            config: parsedConfig,
+            options,
+            bounds: findMapBoundsIfCentered(filterNewlyAddedLayers(visState.layers))
+          })
+        )
+      )
+    ),
+
+    pick_('mapStyle')(apply_(styleMapConfigUpdater, payload_({config: parsedConfig, options}))),
+
+    pick_('uiState')(apply_(uiStateLoadFilesSuccessUpdater, payload_(null))),
+
+    pick_('uiState')(apply_(toggleModalUpdater, payload_(null))),
+
+    pick_('uiState')(merge_(options.hasOwnProperty('readOnly') ? {readOnly: options.readOnly} : {}))
+  ])(state);
+};
+
+/**
+ * @type {typeof import('./combined-updaters').loadFilesSuccessUpdater}
+ */
+export const loadFilesSuccessUpdater = (state, action) => {
+  // still more to load
+  const payloads = filesToDataPayload(action.result);
+  const nextState = compose_([
+    pick_('visState')(
+      merge_({
+        fileLoading: false,
+        fileLoadingProgress: {}
+      })
+    )
+  ])(state);
+  // make multiple add data to map calls
+  const stateWithData = compose_(payloads.map(p => apply_(addDataToMapUpdater, payload_(p))))(
+    nextState
+  );
+  return stateWithData;
+};
+
+export const addDataToMapComposed = addDataToMapUpdater;

package/src/reducers/composer-helpers.d.ts

@@ -0,0 +1,32 @@
+/** Returns a function that logs a value with a given message */
+export declare function log(text: string): (value: any) => void;
+
+/** Wraps a value in an object and stores it the `payload` field */
+export declare function payload_<P>(payload: P): {payload: P};
+
+/** Wraps a value in an object and stores it the `payload` field */
+export declare function compose_<State>(fns: Array<(s: State) => State>): (s: State) => State;
+
+/** TBA */
+export declare function apply_<State, P>(
+  updater: (s: State, p: P) => State,
+  payload: P
+): (s: State) => State;
+
+/** TBA */
+export declare function pick_<State, Prop extends keyof State>(
+  prop: Prop
+): (fn: (p: State[Prop]) => State[Prop]) => (state: State) => State;
+
+/** Returns a reducer function that merges props with state */
+export declare function merge_<State, Props>(object: Props): (state: State) => State & Props;
+
+export declare function pickKepler_<X>(fn: (x: X) => X): (s: {keplerGL: {map: X}}) => {keplerGL: {map: X}};
+
+export declare function swap_<X>(item: X): (arr: X[]) => X[];
+
+export declare function findById<X>(id: string): (arr: X[]) => X | undefined;
+
+export declare function with_<State>(fn: (state: State) => State): (state: State) => State;
+
+export declare function if_(pred: boolean, fn: (state: State) => State): (state: State) => State;

package/src/reducers/composer-helpers.js

@@ -0,0 +1,70 @@
+// 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 from 'global/console';
+
+const identity = state => state;
+
+/* eslint-disable no-unused-vars */
+// @ts-ignore
+export function log(text) {
+  return value => Console.log(text, value);
+}
+/* eslint-enable no-unused-vars */
+
+export function payload_(p) {
+  return {payload: p};
+}
+
+export function apply_(updater, payload) {
+  return state => updater(state, payload);
+}
+
+export function with_(fn) {
+  return state => fn(state)(state);
+}
+
+export function if_(pred, fn) {
+  return pred ? fn : identity;
+}
+
+export function compose_(fns) {
+  return state => fns.reduce((state2, fn) => fn(state2), state);
+}
+
+export function merge_(obj) {
+  return state => ({...state, ...obj});
+}
+
+export function pick_(prop) {
+  return fn => state => ({...state, [prop]: fn(state[prop])});
+}
+
+export function swap_(item) {
+  return arr => arr.map(a => (a.id === item.id ? item : a));
+}
+
+export function findById(id) {
+  return arr => arr.find(a => a.id === id);
+}
+
+export function map_(fn) {
+  return arr => arr.map(e => fn(e));
+}

package/src/reducers/composers.js

@@ -0,0 +1,33 @@
+// 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 ActionTypes from 'constants/action-types';
+import * as combinedUpdaters from './combined-updaters';
+
+/**
+ * Important: Do not rename `actionHandler` or the assignment pattern of property value.
+ * It is used to generate documentation
+ */
+const actionHandler = {
+  [ActionTypes.ADD_DATA_TO_MAP]: combinedUpdaters.addDataToMapUpdater,
+  [ActionTypes.LOAD_FILES_SUCCESS]: combinedUpdaters.loadFilesSuccessUpdater
+};
+
+export default actionHandler;