@carto/kepler.gl 0.0.76 → 0.0.78-0

package/src/processors/file-handler.ts

@@ -0,0 +1,248 @@
+// 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';
+import {LoaderObject} from '@loaders.gl/loader-utils';
+import {AddDataToMapPayload} from 'actions/actions';
+import {FileCacheItem, ValidKeplerGlMap} from './types';
+import {Feature} from 'reducers';
+import {FeatureCollection} from '@turf/helpers';
+
+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: unknown): json is Feature | FeatureCollection {
+  // json can be feature collection
+  // or single feature
+  return isPlainObject(json) && (isFeature(json) || isFeatureCollection(json));
+}
+
+export function isFeature(json: unknown): json is Feature {
+  return isPlainObject(json) && json.type === 'Feature' && !!json.geometry;
+}
+
+export function isFeatureCollection(json: unknown): json is FeatureCollection {
+  return isPlainObject(json) && json.type === 'FeatureCollection' && !!json.features;
+}
+
+export function isRowObject(json: any): boolean {
+  return Array.isArray(json) && isPlainObject(json[0]);
+}
+
+export function isKeplerGlMap(json: unknown): json is ValidKeplerGlMap {
+  return Boolean(
+    isPlainObject(json) &&
+      json.datasets &&
+      json.config &&
+      json.info &&
+      isPlainObject(json.info) &&
+      json.info.app === 'kepler.gl'
+  );
+}
+
+export async function* makeProgressIterator(
+  asyncIterator: AsyncIterable<any>,
+  info: {size: number}
+): AsyncGenerator {
+  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,
+      ...(Number.isFinite(percent) ? {percent} : {})
+    };
+
+    yield {...batch, progress};
+  }
+}
+
+// eslint-disable-next-line complexity
+export async function* readBatch(
+  asyncIterator: AsyncIterable<any>,
+  fileName: string
+): AsyncGenerator {
+  let result = null;
+  const batches = <any>[];
+
+  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,
+  loaders = [],
+  loadOptions = {}
+}: {
+  file: File;
+  fileCache: FileCacheItem[];
+  loaders: LoaderObject[];
+  loadOptions: any;
+}): Promise<AsyncGenerator> {
+  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
+}: {
+  content: {data: unknown; fileName: string};
+  fileCache: FileCacheItem[];
+}): Promise<FileCacheItem[]> {
+  return new Promise((resolve, reject) => {
+    const {data} = content;
+
+    let format: string | undefined;
+    let processor: Function | undefined;
+    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('Unknown File Format');
+  });
+}
+
+export function filesToDataPayload(fileCache: FileCacheItem[]): AddDataToMapPayload[] {
+  // seperate out files which could be a single datasets. or a keplergl map json
+  const collection = fileCache.reduce<{
+    datasets: FileCacheItem[];
+    keplerMaps: AddDataToMapPayload[];
+  }>(
+    (accu, file) => {
+      const {data, info} = file;
+      if (info?.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[info?.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.ts

@@ -0,0 +1,22 @@
+// 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.
+
+export * from './data-processor';
+export * from './file-handler';

package/src/processors/types.ts

@@ -0,0 +1,22 @@
+import {Field} from 'utils/table-utils/kepler-table';
+
+export type FileCacheItem = {
+  data: any;
+  info: {
+    id?: string;
+    label: string;
+    format: string;
+  };
+};
+
+export type RowData = {
+  [key: string]: string | null;
+}[];
+
+export type ProcessorResult = {fields: Field[]; rows: any[][]} | null;
+
+export type ValidKeplerGlMap = {
+  datasets: unknown;
+  config: unknown;
+  info: Record<string, string>;
+};

package/src/reducers/combined-updaters.ts

@@ -0,0 +1,216 @@
+// 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';
+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 {loadFilesSuccessUpdaterAction} from 'actions/vis-state-actions';
+import {ParsedConfig} from 'schemas';
+import {Layer} from 'layers';
+
+export type KeplerGlState = {
+  visState: VisState;
+  mapState: MapState;
+  mapStyle: MapStyle;
+  uiState: UiState;
+  providerState: ProviderState;
+};
+
+// 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`
+ *
+ * @public
+ */
+export const addDataToMapUpdater = (
+  state: KeplerGlState,
+  {payload}: {payload: AddDataToMapPayload}
+): KeplerGlState => {
+  const {datasets, config, info} = payload;
+
+  const options = {
+    ...defaultAddDataToMapOptions,
+    ...payload.options
+  };
+
+  // @ts-expect-error
+  let parsedConfig: ParsedConfig = config;
+
+  if (isValidConfig(config)) {
+    // if passed in saved config
+    // @ts-expect-error
+    parsedConfig = state.visState.schema.parseSavedConfig(config);
+  }
+  const oldLayers = state.visState.layers;
+  const filterNewlyAddedLayers = (layers: Layer[]) =>
+    layers.filter(nl => !oldLayers.find(ol => ol === nl));
+
+  // Returns undefined if not found, to make typescript happy
+  const findMapBoundsIfCentered = (layers: Layer[]) => {
+    const bounds = options.centerMap && findMapBounds(layers);
+    return bounds ? bounds : undefined;
+  };
+
+  return compose_<KeplerGlState>([
+    pick_('visState')(
+      apply_(visStateUpdateVisDataUpdater, {
+        datasets,
+        options,
+        config: parsedConfig
+      })
+    ),
+
+    if_(Boolean(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);
+};
+
+export const loadFilesSuccessUpdater = (
+  state: KeplerGlState,
+  action: loadFilesSuccessUpdaterAction
+): KeplerGlState => {
+  // 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.ts

@@ -0,0 +1,75 @@
+// 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;
+
+/** Returns a function that logs a value with a given message */
+export function log(text: string): (value: any) => void {
+  return value => Console.log(text, value);
+}
+/** Wraps a value in an object and stores it the `payload` field */
+export function payload_<P>(payload: P) {
+  return {payload};
+}
+/** Wraps a value in an object and stores it the `payload` field */
+export function apply_<State, P>(
+  updater: (state: State, payload: P) => State,
+  payload: P
+): (state: State) => State {
+  return state => updater(state, payload);
+}
+
+export function with_<State>(
+  fn: (state: State) => (state: State) => State
+): (state: State) => State {
+  return state => fn(state)(state);
+}
+
+export function if_<State>(pred: boolean, fn: (state: State) => State): (state: State) => State {
+  return pred ? fn : identity;
+}
+
+export function compose_<State>(fns: Array<(s: State) => State>): (s: State) => State {
+  return state => fns.reduce((state2, fn) => fn(state2), state);
+}
+/** Returns a reducer function that merges props with state */
+export function merge_<Props>(obj: Props): <State>(state: State) => State {
+  return state => ({...state, ...obj});
+}
+
+export function pick_<Prop extends string>(
+  prop: Prop
+): <Value>(fn: (p: Value) => Value) => <State extends Record<Prop, Value>>(state: State) => State {
+  return fn => state => ({...state, [prop]: fn(state[prop])});
+}
+
+export function swap_<X extends {id: string}>(item: X): (arr: X[]) => X[] {
+  return arr => arr.map(a => (a.id === item.id ? item : a));
+}
+
+export function findById<X extends {id: string}>(id: string): (arr: X[]) => X | undefined {
+  return arr => arr.find(a => a.id === id);
+}
+
+export function map_<X>(fn: (state: X) => X): (arr: X[]) => X[] {
+  return arr => arr.map(e => fn(e));
+}

package/src/reducers/core.ts

@@ -0,0 +1,111 @@
+// 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 {combineReducers} from 'redux';
+
+import {visStateReducerFactory} from './vis-state';
+import {mapStateReducerFactory} from './map-state';
+import {mapStyleReducerFactory} from './map-style';
+import {uiStateReducerFactory} from './ui-state';
+import {providerStateReducerFactory} from './provider-state';
+
+import composers from './composers';
+
+import {VisState} from './vis-state-updaters';
+import {MapState} from './map-state-updaters';
+import {MapStyle} from './map-style-updaters';
+import {ProviderState} from './provider-state-updaters';
+import {UiState} from './ui-state-updaters';
+
+export type KeplerGlState = {
+  visState: VisState;
+  mapState: MapState;
+  mapStyle: MapStyle;
+  uiState: UiState;
+  providerState: ProviderState;
+};
+
+const combined = (initialState: Partial<KeplerGlState> = {}) =>
+  combineReducers({
+    visState: visStateReducerFactory(initialState.visState),
+    mapState: mapStateReducerFactory(initialState.mapState),
+    mapStyle: mapStyleReducerFactory(initialState.mapStyle),
+    uiState: uiStateReducerFactory(initialState.uiState),
+    providerState: providerStateReducerFactory(initialState.providerState)
+  });
+
+export const coreReducerFactory = (initialState: Partial<KeplerGlState> = {}) => (
+  state,
+  action
+) => {
+  if (composers[action.type]) {
+    return composers[action.type](state, action);
+  }
+  return combined(initialState)(state, action);
+};
+
+export default coreReducerFactory();
+
+/**
+ * Connect subreducer `mapState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export const mapStateLens = (reduxState: KeplerGlState) => ({mapState: reduxState.mapState});
+
+/**
+ * Connect subreducer `mapStyle`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export const mapStyleLens = (reduxState: KeplerGlState) => ({mapStyle: reduxState.mapStyle});
+
+/**
+ * Connect subreducer `visState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export const visStateLens = (reduxState: KeplerGlState) => ({visState: reduxState.visState});
+
+/**
+ * Connect subreducer `uiState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export const uiStateLens = (reduxState: KeplerGlState) => ({uiState: reduxState.uiState});
+
+/**
+ * Connect subreducer `providerState`, used with `injectComponents`. Learn more at
+ * [Replace UI Component](../advanced-usages/replace-ui-component.md#pass-custom-component-props)
+ *
+ * @param {*} reduxState
+ * @public
+ */
+export const providerStateLens = (reduxState: KeplerGlState) => ({
+  providerState: reduxState.providerState
+});