@carto/kepler.gl 0.1.0-alpha.0 → 0.1.0-next.0

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

@@ -1,52 +1,52 @@
-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';
-export type KeplerGlState = {
-    visState: VisState;
-    mapState: MapState;
-    mapStyle: MapStyle;
-    uiState: UiState;
-    providerState: ProviderState;
-};
-export declare const isValidConfig: (config: any) => unknown;
-export declare const defaultAddDataToMapOptions: {
-    centerMap: boolean;
-    keepExistingConfig: boolean;
-    autoCreateLayers: boolean;
-};
-/**
- * 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 declare const addDataToMapUpdater: (state: KeplerGlState, { payload }: {
-    payload: AddDataToMapPayload;
-}) => KeplerGlState;
-export declare const loadFilesSuccessUpdater: (state: KeplerGlState, action: loadFilesSuccessUpdaterAction) => KeplerGlState;
-export declare const addDataToMapComposed: (state: KeplerGlState, { payload }: {
-    payload: AddDataToMapPayload;
-}) => KeplerGlState;
+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';
+export type KeplerGlState = {
+    visState: VisState;
+    mapState: MapState;
+    mapStyle: MapStyle;
+    uiState: UiState;
+    providerState: ProviderState;
+};
+export declare const isValidConfig: (config: any) => unknown;
+export declare const defaultAddDataToMapOptions: {
+    centerMap: boolean;
+    keepExistingConfig: boolean;
+    autoCreateLayers: boolean;
+};
+/**
+ * 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 declare const addDataToMapUpdater: (state: KeplerGlState, { payload }: {
+    payload: AddDataToMapPayload;
+}) => KeplerGlState;
+export declare const loadFilesSuccessUpdater: (state: KeplerGlState, action: loadFilesSuccessUpdaterAction) => KeplerGlState;
+export declare const addDataToMapComposed: (state: KeplerGlState, { payload }: {
+    payload: AddDataToMapPayload;
+}) => KeplerGlState;

package/dist/reducers/combined-updaters.js

@@ -0,0 +1,180 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadFilesSuccessUpdater = exports.isValidConfig = exports.defaultAddDataToMapOptions = exports.addDataToMapUpdater = exports.addDataToMapComposed = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _uiStateUpdaters = require("./ui-state-updaters");
+var _visStateUpdaters = require("./vis-state-updaters");
+var _mapStateUpdaters = require("./map-state-updaters");
+var _mapStyleUpdaters = require("./map-style-updaters");
+var _dataUtils = require("../utils/data-utils");
+var _utils = require("../utils/utils");
+var _fileHandler = require("../processors/file-handler");
+var _composerHelpers = require("./composer-helpers");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // 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.
+// 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
+var combinedUpdaters = null;
+/* eslint-enable no-unused-vars */
+
+var isValidConfig = exports.isValidConfig = function isValidConfig(config) {
+  return (0, _utils.isPlainObject)(config) && (0, _utils.isPlainObject)(config.config) && config.version;
+};
+var defaultAddDataToMapOptions = exports.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
+ */
+var addDataToMapUpdater = exports.addDataToMapUpdater = function addDataToMapUpdater(state, _ref) {
+  var payload = _ref.payload;
+  var datasets = payload.datasets,
+    config = payload.config,
+    info = payload.info;
+  var options = _objectSpread(_objectSpread({}, defaultAddDataToMapOptions), payload.options);
+  var parsedConfig = config;
+  if (isValidConfig(config)) {
+    // if passed in saved config
+    // @ts-expect-error
+    parsedConfig = state.visState.schema.parseSavedConfig(config);
+  }
+  var oldLayers = state.visState.layers;
+  var filterNewlyAddedLayers = function filterNewlyAddedLayers(layers) {
+    return layers.filter(function (nl) {
+      return !oldLayers.find(function (ol) {
+        return ol === nl;
+      });
+    });
+  };
+
+  // Returns undefined if not found, to make typescript happy
+  var findMapBoundsIfCentered = function findMapBoundsIfCentered(layers) {
+    var bounds = options.centerMap && (0, _dataUtils.findMapBounds)(layers);
+    return bounds ? bounds : undefined;
+  };
+  return (0, _composerHelpers.compose_)([(0, _composerHelpers.pick_)('visState')((0, _composerHelpers.apply_)(_visStateUpdaters.updateVisDataUpdater, {
+    datasets: datasets,
+    options: options,
+    config: parsedConfig
+  })), (0, _composerHelpers.if_)(Boolean(info), (0, _composerHelpers.pick_)('visState')((0, _composerHelpers.apply_)(_visStateUpdaters.setMapInfoUpdater, {
+    info: info
+  }))), (0, _composerHelpers.with_)(function (_ref2) {
+    var visState = _ref2.visState;
+    return (0, _composerHelpers.pick_)('mapState')((0, _composerHelpers.apply_)(_mapStateUpdaters.receiveMapConfigUpdater, (0, _composerHelpers.payload_)({
+      config: parsedConfig,
+      options: options,
+      bounds: findMapBoundsIfCentered(filterNewlyAddedLayers(visState.layers))
+    })));
+  }), (0, _composerHelpers.pick_)('mapStyle')((0, _composerHelpers.apply_)(_mapStyleUpdaters.receiveMapConfigUpdater, (0, _composerHelpers.payload_)({
+    config: parsedConfig,
+    options: options
+  }))), (0, _composerHelpers.pick_)('uiState')((0, _composerHelpers.apply_)(_uiStateUpdaters.loadFilesSuccessUpdater, (0, _composerHelpers.payload_)(null))), (0, _composerHelpers.pick_)('uiState')((0, _composerHelpers.apply_)(_uiStateUpdaters.toggleModalUpdater, (0, _composerHelpers.payload_)(null))), (0, _composerHelpers.pick_)('uiState')((0, _composerHelpers.merge_)(options.hasOwnProperty('readOnly') ? {
+    readOnly: options.readOnly
+  } : {}))])(state);
+};
+var loadFilesSuccessUpdater = exports.loadFilesSuccessUpdater = function loadFilesSuccessUpdater(state, action) {
+  // still more to load
+  var payloads = (0, _fileHandler.filesToDataPayload)(action.result);
+  var nextState = (0, _composerHelpers.compose_)([(0, _composerHelpers.pick_)('visState')((0, _composerHelpers.merge_)({
+    fileLoading: false,
+    fileLoadingProgress: {}
+  }))])(state);
+  // make multiple add data to map calls
+  var stateWithData = (0, _composerHelpers.compose_)(payloads.map(function (p) {
+    return (0, _composerHelpers.apply_)(addDataToMapUpdater, (0, _composerHelpers.payload_)(p));
+  }))(nextState);
+  return stateWithData;
+};
+var addDataToMapComposed = exports.addDataToMapComposed = addDataToMapUpdater;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_uiStateUpdaters","require","_visStateUpdaters","_mapStateUpdaters","_mapStyleUpdaters","_dataUtils","_utils","_fileHandler","_composerHelpers","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","combinedUpdaters","isValidConfig","exports","config","isPlainObject","version","defaultAddDataToMapOptions","centerMap","keepExistingConfig","autoCreateLayers","addDataToMapUpdater","state","_ref","payload","datasets","info","options","parsedConfig","visState","schema","parseSavedConfig","oldLayers","layers","filterNewlyAddedLayers","nl","find","ol","findMapBoundsIfCentered","bounds","findMapBounds","undefined","compose_","pick_","apply_","visStateUpdateVisDataUpdater","if_","Boolean","setMapInfoUpdater","with_","_ref2","stateMapConfigUpdater","payload_","styleMapConfigUpdater","uiStateLoadFilesSuccessUpdater","toggleModalUpdater","merge_","hasOwnProperty","readOnly","loadFilesSuccessUpdater","action","payloads","filesToDataPayload","result","nextState","fileLoading","fileLoadingProgress","stateWithData","map","p","addDataToMapComposed"],"sources":["../../src/reducers/combined-updaters.ts"],"sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {\n  toggleModalUpdater,\n  loadFilesSuccessUpdater as uiStateLoadFilesSuccessUpdater\n} from './ui-state-updaters';\nimport {\n  updateVisDataUpdater as visStateUpdateVisDataUpdater,\n  setMapInfoUpdater\n} from './vis-state-updaters';\nimport {receiveMapConfigUpdater as stateMapConfigUpdater} from './map-state-updaters';\nimport {receiveMapConfigUpdater as styleMapConfigUpdater} from './map-style-updaters';\nimport {findMapBounds} from 'utils/data-utils';\nimport {isPlainObject} from 'utils/utils';\nimport {filesToDataPayload} from 'processors/file-handler';\nimport {payload_, apply_, with_, if_, compose_, merge_, pick_} from './composer-helpers';\nimport {VisState} from './vis-state-updaters';\nimport {MapState} from './map-state-updaters';\nimport {UiState} from './ui-state-updaters';\nimport {MapStyle} from './map-style-updaters';\nimport {ProviderState} from './provider-state-updaters';\nimport {AddDataToMapPayload} from 'actions/actions';\nimport {loadFilesSuccessUpdaterAction} from 'actions/vis-state-actions';\nimport {ParsedConfig} from 'schemas';\nimport {Layer} from 'layers';\n\nexport type KeplerGlState = {\n  visState: VisState;\n  mapState: MapState;\n  mapStyle: MapStyle;\n  uiState: UiState;\n  providerState: ProviderState;\n};\n\n// compose action to apply result multiple reducers, with the output of one\n\n/**\n * Some actions will affect the entire kepler.lg instance state.\n * The updaters for these actions is exported as `combinedUpdaters`. These updater take the entire instance state\n * as the first argument. Read more about [Using updaters](../advanced-usage/using-updaters.md)\n * @public\n * @example\n *\n * import keplerGlReducer, {combinedUpdaters} from 'kepler.gl/reducers';\n * // Root Reducer\n * const reducers = combineReducers({\n *  keplerGl: keplerGlReducer,\n *  app: appReducer\n * });\n *\n * const composedReducer = (state, action) => {\n *  switch (action.type) {\n *    // add data to map after receiving data from remote sources\n *    case 'LOAD_REMOTE_RESOURCE_SUCCESS':\n *      return {\n *        ...state,\n *        keplerGl: {\n *          ...state.keplerGl,\n *          // pass in kepler.gl instance state to combinedUpdaters\n *          map:  combinedUpdaters.addDataToMapUpdater(\n *           state.keplerGl.map,\n *           {\n *             payload: {\n *               datasets: action.datasets,\n *               options: {readOnly: true},\n *               config: action.config\n *              }\n *            }\n *          )\n *        }\n *      };\n *  }\n *  return reducers(state, action);\n * };\n *\n * export default composedReducer;\n */\n\n/* eslint-disable no-unused-vars */\n// @ts-ignore\nconst combinedUpdaters = null;\n/* eslint-enable no-unused-vars */\n\nexport const isValidConfig = config =>\n  isPlainObject(config) && isPlainObject(config.config) && config.version;\n\nexport const defaultAddDataToMapOptions = {\n  centerMap: true,\n  keepExistingConfig: false,\n  autoCreateLayers: true\n};\n\n/**\n * Combine data and full configuration update in a single action\n *\n * @memberof combinedUpdaters\n * @param {Object} state kepler.gl instance state, containing all subreducer state\n * @param {Object} action\n * @param {Object} action.payload `{datasets, options, config}`\n * @param action.payload.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 [action.payload.options] option object `{centerMap: true}`\n * @param [action.payload.config] map config\n * @param [action.payload.info] map info contains title and description\n * @returns nextState\n *\n * @typedef {Object} Dataset\n * @property info -info of a dataset\n * @property info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.\n * @property info.label - A display name of this dataset\n * @property data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`\n * @property data.fields - ***required** Array of fields,\n * @property data.fields.name - ***required** Name of the field,\n * @property data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`\n *\n * @public\n */\nexport const addDataToMapUpdater = (\n  state: KeplerGlState,\n  {payload}: {payload: AddDataToMapPayload}\n): KeplerGlState => {\n  const {datasets, config, info} = payload;\n\n  const options = {\n    ...defaultAddDataToMapOptions,\n    ...payload.options\n  };\n\n  let parsedConfig: ParsedConfig = config;\n\n  if (isValidConfig(config)) {\n    // if passed in saved config\n    // @ts-expect-error\n    parsedConfig = state.visState.schema.parseSavedConfig(config);\n  }\n  const oldLayers = state.visState.layers;\n  const filterNewlyAddedLayers = (layers: Layer[]) =>\n    layers.filter(nl => !oldLayers.find(ol => ol === nl));\n\n  // Returns undefined if not found, to make typescript happy\n  const findMapBoundsIfCentered = (layers: Layer[]) => {\n    const bounds = options.centerMap && findMapBounds(layers);\n    return bounds ? bounds : undefined;\n  };\n\n  return compose_<KeplerGlState>([\n    pick_('visState')(\n      apply_(visStateUpdateVisDataUpdater, {\n        datasets,\n        options,\n        config: parsedConfig\n      })\n    ),\n\n    if_(Boolean(info), pick_('visState')(apply_(setMapInfoUpdater, {info}))),\n\n    with_(({visState}) =>\n      pick_('mapState')(\n        apply_(\n          stateMapConfigUpdater,\n          payload_({\n            config: parsedConfig,\n            options,\n            bounds: findMapBoundsIfCentered(filterNewlyAddedLayers(visState.layers))\n          })\n        )\n      )\n    ),\n    pick_('mapStyle')(apply_(styleMapConfigUpdater, payload_({config: parsedConfig, options}))),\n    pick_('uiState')(apply_(uiStateLoadFilesSuccessUpdater, payload_(null))),\n    pick_('uiState')(apply_(toggleModalUpdater, payload_(null))),\n    pick_('uiState')(merge_(options.hasOwnProperty('readOnly') ? {readOnly: options.readOnly} : {}))\n  ])(state);\n};\n\nexport const loadFilesSuccessUpdater = (\n  state: KeplerGlState,\n  action: loadFilesSuccessUpdaterAction\n): KeplerGlState => {\n  // still more to load\n  const payloads = filesToDataPayload(action.result);\n  const nextState = compose_([\n    pick_('visState')(\n      merge_({\n        fileLoading: false,\n        fileLoadingProgress: {}\n      })\n    )\n  ])(state);\n  // make multiple add data to map calls\n  const stateWithData = compose_(payloads.map(p => apply_(addDataToMapUpdater, payload_(p))))(\n    nextState\n  );\n  return stateWithData;\n};\n\nexport const addDataToMapComposed = addDataToMapUpdater;\n"],"mappings":"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","ignoreList":[]}

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

@@ -1,21 +1,21 @@
-/** 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 apply_<State, P>(updater: (state: State, payload: P) => State, payload: P): (state: State) => State;
-export declare function with_<State>(fn: (state: State) => (state: State) => State): (state: State) => State;
-export declare function if_<State>(pred: boolean, fn: (state: State) => State): (state: State) => State;
-export declare function compose_<State>(fns: Array<(s: State) => State>): (s: State) => State;
-/** Returns a reducer function that merges props with state */
-export declare function merge_<Props>(obj: Props): <State>(state: State) => State;
-export declare function pick_<Prop extends string>(prop: Prop): <Value>(fn: (p: Value) => Value) => <State extends Record<Prop, Value>>(state: State) => State;
-export declare function swap_<X extends {
-    id: string;
-}>(item: X): (arr: X[]) => X[];
-export declare function findById<X extends {
-    id: string;
-}>(id: string): (arr: X[]) => X | undefined;
-export declare function map_<X>(fn: (state: X) => X): (arr: X[]) => X[];
+/** 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 apply_<State, P>(updater: (state: State, payload: P) => State, payload: P): (state: State) => State;
+export declare function with_<State>(fn: (state: State) => (state: State) => State): (state: State) => State;
+export declare function if_<State>(pred: boolean, fn: (state: State) => State): (state: State) => State;
+export declare function compose_<State>(fns: Array<(s: State) => State>): (s: State) => State;
+/** Returns a reducer function that merges props with state */
+export declare function merge_<Props>(obj: Props): <State>(state: State) => State;
+export declare function pick_<Prop extends string>(prop: Prop): <Value>(fn: (p: Value) => Value) => <State extends Record<Prop, Value>>(state: State) => State;
+export declare function swap_<X extends {
+    id: string;
+}>(item: X): (arr: X[]) => X[];
+export declare function findById<X extends {
+    id: string;
+}>(id: string): (arr: X[]) => X | undefined;
+export declare function map_<X>(fn: (state: X) => X): (arr: X[]) => X[];

package/dist/reducers/composer-helpers.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.apply_ = apply_;
+exports.compose_ = compose_;
+exports.findById = findById;
+exports.if_ = if_;
+exports.log = log;
+exports.map_ = map_;
+exports.merge_ = merge_;
+exports.payload_ = payload_;
+exports.pick_ = pick_;
+exports.swap_ = swap_;
+exports.with_ = with_;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _console = _interopRequireDefault(require("global/console"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // 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.
+var identity = function identity(state) {
+  return state;
+};
+
+/** Returns a function that logs a value with a given message */
+function log(text) {
+  return function (value) {
+    return _console["default"].log(text, value);
+  };
+}
+/** Wraps a value in an object and stores it the `payload` field */
+function payload_(payload) {
+  return {
+    payload: payload
+  };
+}
+/** Wraps a value in an object and stores it the `payload` field */
+function apply_(updater, payload) {
+  return function (state) {
+    return updater(state, payload);
+  };
+}
+function with_(fn) {
+  return function (state) {
+    return fn(state)(state);
+  };
+}
+function if_(pred, fn) {
+  return pred ? fn : identity;
+}
+function compose_(fns) {
+  return function (state) {
+    return fns.reduce(function (state2, fn) {
+      return fn(state2);
+    }, state);
+  };
+}
+/** Returns a reducer function that merges props with state */
+function merge_(obj) {
+  return function (state) {
+    return _objectSpread(_objectSpread({}, state), obj);
+  };
+}
+function pick_(prop) {
+  return function (fn) {
+    return function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, (0, _defineProperty2["default"])({}, prop, fn(state[prop])));
+    };
+  };
+}
+function swap_(item) {
+  return function (arr) {
+    return arr.map(function (a) {
+      return a.id === item.id ? item : a;
+    });
+  };
+}
+function findById(id) {
+  return function (arr) {
+    return arr.find(function (a) {
+      return a.id === id;
+    });
+  };
+}
+function map_(fn) {
+  return function (arr) {
+    return arr.map(function (e) {
+      return fn(e);
+    });
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_console","_interopRequireDefault","require","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","identity","state","log","text","value","Console","payload_","payload","apply_","updater","with_","fn","if_","pred","compose_","fns","reduce","state2","merge_","obj","pick_","prop","swap_","item","arr","map","a","id","findById","find","map_"],"sources":["../../src/reducers/composer-helpers.ts"],"sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport Console from 'global/console';\n\nconst identity = state => state;\n\n/** Returns a function that logs a value with a given message */\nexport function log(text: string): (value: any) => void {\n  return value => Console.log(text, value);\n}\n/** Wraps a value in an object and stores it the `payload` field */\nexport function payload_<P>(payload: P) {\n  return {payload};\n}\n/** Wraps a value in an object and stores it the `payload` field */\nexport function apply_<State, P>(\n  updater: (state: State, payload: P) => State,\n  payload: P\n): (state: State) => State {\n  return state => updater(state, payload);\n}\n\nexport function with_<State>(\n  fn: (state: State) => (state: State) => State\n): (state: State) => State {\n  return state => fn(state)(state);\n}\n\nexport function if_<State>(pred: boolean, fn: (state: State) => State): (state: State) => State {\n  return pred ? fn : identity;\n}\n\nexport function compose_<State>(fns: Array<(s: State) => State>): (s: State) => State {\n  return state => fns.reduce((state2, fn) => fn(state2), state);\n}\n/** Returns a reducer function that merges props with state */\nexport function merge_<Props>(obj: Props): <State>(state: State) => State {\n  return state => ({...state, ...obj});\n}\n\nexport function pick_<Prop extends string>(\n  prop: Prop\n): <Value>(fn: (p: Value) => Value) => <State extends Record<Prop, Value>>(state: State) => State {\n  return fn => state => ({...state, [prop]: fn(state[prop])});\n}\n\nexport function swap_<X extends {id: string}>(item: X): (arr: X[]) => X[] {\n  return arr => arr.map(a => (a.id === item.id ? item : a));\n}\n\nexport function findById<X extends {id: string}>(id: string): (arr: X[]) => X | undefined {\n  return arr => arr.find(a => a.id === id);\n}\n\nexport function map_<X>(fn: (state: X) => X): (arr: X[]) => X[] {\n  return arr => arr.map(e => fn(e));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,IAAAA,QAAA,GAAAC,sBAAA,CAAAC,OAAA;AAAqC,SAAAC,QAAAC,CAAA,EAAAC,CAAA,QAAAC,CAAA,GAAAC,MAAA,CAAAC,IAAA,CAAAJ,CAAA,OAAAG,MAAA,CAAAE,qBAAA,QAAAC,CAAA,GAAAH,MAAA,CAAAE,qBAAA,CAAAL,CAAA,GAAAC,CAAA,KAAAK,CAAA,GAAAA,CAAA,CAAAC,MAAA,WAAAN,CAAA,WAAAE,MAAA,CAAAK,wBAAA,CAAAR,CAAA,EAAAC,CAAA,EAAAQ,UAAA,OAAAP,CAAA,CAAAQ,IAAA,CAAAC,KAAA,CAAAT,CAAA,EAAAI,CAAA,YAAAJ,CAAA;AAAA,SAAAU,cAAAZ,CAAA,aAAAC,CAAA,MAAAA,CAAA,GAAAY,SAAA,CAAAC,MAAA,EAAAb,CAAA,UAAAC,CAAA,WAAAW,SAAA,CAAAZ,CAAA,IAAAY,SAAA,CAAAZ,CAAA,QAAAA,CAAA,OAAAF,OAAA,CAAAI,MAAA,CAAAD,CAAA,OAAAa,OAAA,WAAAd,CAAA,QAAAe,gBAAA,aAAAhB,CAAA,EAAAC,CAAA,EAAAC,CAAA,CAAAD,CAAA,SAAAE,MAAA,CAAAc,yBAAA,GAAAd,MAAA,CAAAe,gBAAA,CAAAlB,CAAA,EAAAG,MAAA,CAAAc,yBAAA,CAAAf,CAAA,KAAAH,OAAA,CAAAI,MAAA,CAAAD,CAAA,GAAAa,OAAA,WAAAd,CAAA,IAAAE,MAAA,CAAAgB,cAAA,CAAAnB,CAAA,EAAAC,CAAA,EAAAE,MAAA,CAAAK,wBAAA,CAAAN,CAAA,EAAAD,CAAA,iBAAAD,CAAA,IApBrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAIA,IAAMoB,QAAQ,GAAG,SAAXA,QAAQA,CAAGC,KAAK;EAAA,OAAIA,KAAK;AAAA;;AAE/B;AACO,SAASC,GAAGA,CAACC,IAAY,EAAwB;EACtD,OAAO,UAAAC,KAAK;IAAA,OAAIC,mBAAO,CAACH,GAAG,CAACC,IAAI,EAAEC,KAAK,CAAC;EAAA;AAC1C;AACA;AACO,SAASE,QAAQA,CAAIC,OAAU,EAAE;EACtC,OAAO;IAACA,OAAO,EAAPA;EAAO,CAAC;AAClB;AACA;AACO,SAASC,MAAMA,CACpBC,OAA4C,EAC5CF,OAAU,EACe;EACzB,OAAO,UAAAN,KAAK;IAAA,OAAIQ,OAAO,CAACR,KAAK,EAAEM,OAAO,CAAC;EAAA;AACzC;AAEO,SAASG,KAAKA,CACnBC,EAA6C,EACpB;EACzB,OAAO,UAAAV,KAAK;IAAA,OAAIU,EAAE,CAACV,KAAK,CAAC,CAACA,KAAK,CAAC;EAAA;AAClC;AAEO,SAASW,GAAGA,CAAQC,IAAa,EAAEF,EAA2B,EAA2B;EAC9F,OAAOE,IAAI,GAAGF,EAAE,GAAGX,QAAQ;AAC7B;AAEO,SAASc,QAAQA,CAAQC,GAA+B,EAAuB;EACpF,OAAO,UAAAd,KAAK;IAAA,OAAIc,GAAG,CAACC,MAAM,CAAC,UAACC,MAAM,EAAEN,EAAE;MAAA,OAAKA,EAAE,CAACM,MAAM,CAAC;IAAA,GAAEhB,KAAK,CAAC;EAAA;AAC/D;AACA;AACO,SAASiB,MAAMA,CAAQC,GAAU,EAAkC;EACxE,OAAO,UAAAlB,KAAK;IAAA,OAAAT,aAAA,CAAAA,aAAA,KAASS,KAAK,GAAKkB,GAAG;EAAA,CAAE;AACtC;AAEO,SAASC,KAAKA,CACnBC,IAAU,EACsF;EAChG,OAAO,UAAAV,EAAE;IAAA,OAAI,UAAAV,KAAK;MAAA,OAAAT,aAAA,CAAAA,aAAA,KAASS,KAAK,WAAAL,gBAAA,iBAAGyB,IAAI,EAAGV,EAAE,CAACV,KAAK,CAACoB,IAAI,CAAC,CAAC;IAAA,CAAE;EAAA;AAC7D;AAEO,SAASC,KAAKA,CAAyBC,IAAO,EAAqB;EACxE,OAAO,UAAAC,GAAG;IAAA,OAAIA,GAAG,CAACC,GAAG,CAAC,UAAAC,CAAC;MAAA,OAAKA,CAAC,CAACC,EAAE,KAAKJ,IAAI,CAACI,EAAE,GAAGJ,IAAI,GAAGG,CAAC;IAAA,CAAC,CAAC;EAAA;AAC3D;AAEO,SAASE,QAAQA,CAAyBD,EAAU,EAA+B;EACxF,OAAO,UAAAH,GAAG;IAAA,OAAIA,GAAG,CAACK,IAAI,CAAC,UAAAH,CAAC;MAAA,OAAIA,CAAC,CAACC,EAAE,KAAKA,EAAE;IAAA,EAAC;EAAA;AAC1C;AAEO,SAASG,IAAIA,CAAInB,EAAmB,EAAqB;EAC9D,OAAO,UAAAa,GAAG;IAAA,OAAIA,GAAG,CAACC,GAAG,CAAC,UAAA7C,CAAC;MAAA,OAAI+B,EAAE,CAAC/B,CAAC,CAAC;IAAA,EAAC;EAAA;AACnC","ignoreList":[]}

package/dist/reducers/composers.d.ts

@@ -1,12 +1,12 @@
-import * as combinedUpdaters from './combined-updaters';
-/**
- * Important: Do not rename `actionHandler` or the assignment pattern of property value.
- * It is used to generate documentation
- */
-declare const actionHandler: {
-    "@@kepler.gl/ADD_DATA_TO_MAP": (state: combinedUpdaters.KeplerGlState, { payload }: {
-        payload: import("..").AddDataToMapPayload;
-    }) => combinedUpdaters.KeplerGlState;
-    "@@kepler.gl/LOAD_FILES_SUCCESS": (state: combinedUpdaters.KeplerGlState, action: import("..").loadFilesSuccessUpdaterAction) => combinedUpdaters.KeplerGlState;
-};
-export default actionHandler;
+import * as combinedUpdaters from './combined-updaters';
+/**
+ * Important: Do not rename `actionHandler` or the assignment pattern of property value.
+ * It is used to generate documentation
+ */
+declare const actionHandler: {
+    "@@kepler.gl/ADD_DATA_TO_MAP": (state: combinedUpdaters.KeplerGlState, { payload }: {
+        payload: import("..").AddDataToMapPayload;
+    }) => combinedUpdaters.KeplerGlState;
+    "@@kepler.gl/LOAD_FILES_SUCCESS": (state: combinedUpdaters.KeplerGlState, action: import("..").loadFilesSuccessUpdaterAction) => combinedUpdaters.KeplerGlState;
+};
+export default actionHandler;

package/dist/reducers/composers.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _actionTypes = _interopRequireDefault(require("../constants/action-types"));
+var combinedUpdaters = _interopRequireWildcard(require("./combined-updaters"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+// 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.
+
+/**
+ * Important: Do not rename `actionHandler` or the assignment pattern of property value.
+ * It is used to generate documentation
+ */
+var actionHandler = (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _actionTypes["default"].ADD_DATA_TO_MAP, combinedUpdaters.addDataToMapUpdater), _actionTypes["default"].LOAD_FILES_SUCCESS, combinedUpdaters.loadFilesSuccessUpdater);
+var _default = exports["default"] = actionHandler;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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