@kepler.gl/reducers 3.3.0-alpha.5 → 3.3.0-alpha.6

package/dist/esm/composer-helpers.js

@@ -0,0 +1,85 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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) { _defineProperty(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; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import Console from 'global/console';
+var identity = function identity(state) {
+  return state;
+};
+
+/** Returns a function that logs a value with a given message */
+export function log(text) {
+  return function (value) {
+    return Console.log(text, value);
+  };
+}
+/** Wraps a value in an object and stores it the `payload` field */
+export function payload_(payload) {
+  return {
+    payload: payload
+  };
+}
+/** Wraps a value in an object and stores it the `payload` field */
+export function apply_(updater, payload) {
+  return function (state) {
+    return updater(state, payload);
+  };
+}
+export function with_(fn) {
+  return function (state) {
+    return fn(state)(state);
+  };
+}
+export function if_(pred, fn) {
+  return pred ? fn : identity;
+}
+export 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 */
+export function merge_(obj) {
+  return function (state) {
+    return _objectSpread(_objectSpread({}, state), obj);
+  };
+}
+export function pick_(prop) {
+  return function (fn) {
+    return function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, _defineProperty({}, prop, fn(state[prop])));
+    };
+  };
+}
+export function swap_(item) {
+  return function (arr) {
+    return arr.map(function (a) {
+      return a.id === item.id ? item : a;
+    });
+  };
+}
+export function map_(fn) {
+  return function (arr) {
+    return arr.map(function (e) {
+      return fn(e);
+    });
+  };
+}
+export function filterOutById(id) {
+  return function (arr) {
+    return arr.filter(function (e) {
+      return e.id !== id;
+    });
+  };
+}
+export function removeElementAtIndex(index) {
+  return function (arr) {
+    return [].concat(_toConsumableArray(arr.slice(0, index)), _toConsumableArray(arr.slice(index + 1, arr.length)));
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/composers.js

@@ -0,0 +1,14 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { ActionTypes } from '@kepler.gl/actions';
+import * as combinedUpdaters from './combined-updaters';
+
+/**
+ * Important: Do not rename `actionHandler` or the assignment pattern of property value.
+ * It is used to generate documentation
+ */
+var actionHandler = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, ActionTypes.ADD_DATA_TO_MAP, combinedUpdaters.addDataToMapUpdater), ActionTypes.MAP_STYLE_CHANGE, combinedUpdaters.combinedMapStyleChangeUpdater), ActionTypes.SET_MAP_VIEW_MODE, combinedUpdaters.combinedSetMapViewModeUpdater), ActionTypes.LAYER_TYPE_CHANGE, combinedUpdaters.combinedLayerTypeChangeUpdater), ActionTypes.LOAD_FILES_SUCCESS, combinedUpdaters.loadFilesSuccessUpdater), ActionTypes.TOGGLE_SPLIT_MAP, combinedUpdaters.toggleSplitMapUpdater), ActionTypes.SET_MAP_SPLIT_MODE, combinedUpdaters.setMapSplitModeUpdater), ActionTypes.REPLACE_DATA_IN_MAP, combinedUpdaters.replaceDataInMapUpdater);
+export default actionHandler;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/core.js

@@ -0,0 +1,101 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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) { _defineProperty(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; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+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';
+var combined = function combined() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var extraReducers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return combineReducers(_objectSpread({
+    visState: visStateReducerFactory(initialState.visState),
+    mapState: mapStateReducerFactory(initialState.mapState),
+    mapStyle: mapStyleReducerFactory(initialState.mapStyle),
+    uiState: uiStateReducerFactory(initialState.uiState),
+    providerState: providerStateReducerFactory(initialState.providerState)
+  }, extraReducers));
+};
+export var coreReducerFactory = function coreReducerFactory() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var extraReducers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return function (state, action) {
+    if (composers[action.type]) {
+      return composers[action.type](state, action);
+    }
+    return combined(initialState, extraReducers)(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 var mapStateLens = function mapStateLens(reduxState) {
+  return {
+    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 var mapStyleLens = function mapStyleLens(reduxState) {
+  return {
+    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 var visStateLens = function visStateLens(reduxState) {
+  return {
+    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 var uiStateLens = function uiStateLens(reduxState) {
+  return {
+    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 var providerStateLens = function providerStateLens(reduxState) {
+  return {
+    providerState: reduxState.providerState
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/data-utils.js

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { MAX_LATITUDE, MIN_LATITUDE, MAX_LONGITUDE, MIN_LONGITUDE, validateLongitude, validateLatitude } from '@kepler.gl/utils';
+
+/**
+ * takes a list of layer bounds and returns a single bound
+ */
+export function processLayerBounds(layerBounds) {
+  return layerBounds.reduce(function (res, b) {
+    var minLongitude = Math.min(res[0], b[0]);
+    var minLatitude = Math.min(res[1], b[1]);
+    var maxLongitude = Math.max(res[2], b[2]);
+    var maxLatitude = Math.max(res[3], b[3]);
+
+    // for some reason WebMercatorViewport can't handle latitude -90,90 and throws an error
+    // so we default to lat/lng (0,0)
+    // viewport.js:81 Uncaught Error: Pixel project matrix not invertible
+    // at WebMercatorViewport16.Viewport5 (viewport.js:81:13)
+    // at new WebMercatorViewport16 (web-mercator-viewport.js:92:5)
+    // at getViewportFromMapState (map-utils.js:46:66)
+    return [validateLongitude(minLongitude), validateLatitude(minLatitude), validateLongitude(maxLongitude), validateLatitude(maxLatitude)];
+  }, [MAX_LONGITUDE, MAX_LATITUDE, MIN_LONGITUDE, MIN_LATITUDE]);
+}
+
+/**
+ * return center of map from given points
+ * @param layers
+ * @returns coordinates of map center, empty if not found
+ */
+export function findMapBounds(layers) {
+  // find bounds in formatted layerData
+  // take ALL layers into account when finding map bounds
+  var availableLayerBounds = layers.reduce(function (res, l) {
+    if (l.meta && l.meta.bounds) {
+      res.push(l.meta.bounds);
+    }
+    return res;
+  }, []);
+  // return null if no layer is available
+  if (availableLayerBounds.length === 0) {
+    return null;
+  }
+  // merge bounds in each layer
+  return processLayerBounds(availableLayerBounds);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/export-utils.js

@@ -0,0 +1,86 @@
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { Blob } from 'global/window';
+import { csvFormatRows } from 'd3-dsv';
+import { EXPORT_DATA_TYPE } from '@kepler.gl/constants';
+import { createIndexedDataContainer, parseFieldValue, downloadFile } from '@kepler.gl/utils';
+import { getApplicationConfig } from '@kepler.gl/utils';
+export function exportData(state, options) {
+  var visState = state.visState,
+    appName = state.appName;
+  var datasets = visState.datasets;
+  var selectedDataset = options.selectedDataset,
+    dataType = options.dataType,
+    filtered = options.filtered;
+  // get the selected data
+  var filename = appName ? appName : getApplicationConfig().defaultDataName;
+  var selectedDatasets = datasets[selectedDataset] ? [datasets[selectedDataset]] : Object.values(datasets);
+  if (!selectedDatasets.length) {
+    // error: selected dataset not found.
+    return;
+  }
+  selectedDatasets.forEach(function (selectedData) {
+    var _ref = selectedData,
+      dataContainer = _ref.dataContainer,
+      fields = _ref.fields,
+      label = _ref.label,
+      _ref$filteredIdxCPU = _ref.filteredIdxCPU,
+      filteredIdxCPU = _ref$filteredIdxCPU === void 0 ? [] : _ref$filteredIdxCPU;
+    var toExport = filtered ? createIndexedDataContainer(dataContainer, filteredIdxCPU) : dataContainer;
+
+    // start to export data according to selected data type
+    switch (dataType) {
+      case EXPORT_DATA_TYPE.CSV:
+        {
+          var csv = formatCsv(toExport, fields);
+          var fileBlob = new Blob([csv], {
+            type: 'text/csv'
+          });
+          downloadFile(fileBlob, "".concat(filename, "_").concat(label, ".csv"));
+          break;
+        }
+      // TODO: support more file types.
+      default:
+        break;
+    }
+  });
+}
+
+/**
+ * On export data to csv
+ * @param dataContainer
+ * @param fields `dataset.fields`
+ * @returns csv string
+ */
+export function formatCsv(data, fields) {
+  var columns = fields.map(function (f) {
+    return f.displayName || f.name;
+  });
+  var formattedData = [columns];
+
+  // parse geojson object as string
+  var _iterator = _createForOfIteratorHelper(data.rows(true)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var row = _step.value;
+      formattedData.push(row.map(function (d, i) {
+        return parseFieldValue(d, fields[i].type, fields[i]);
+      }));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return csvFormatRows(formattedData);
+}
+var exporters = {
+  exportData: exportData
+};
+export default exporters;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/index.js

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// TODO: Unnecessary when eslint-plugin-prettier is upgraded
+/* eslint-disable prettier/prettier */
+
+// Root Reducer, used to register, and remove core reducers of each instance
+export { default } from './root';
+export { default as keplerGlReducer } from './root';
+
+// Core Reducer
+export { default as keplerGlReducerCore, visStateLens, mapStateLens, uiStateLens, mapStyleLens } from './core';
+
+// Each individual reducer
+export { default as visStateReducer } from './vis-state';
+export { default as mapStateReducer } from './map-state';
+export { default as uiStateReducer } from './ui-state';
+export { default as mapStyleReducer } from './map-style';
+export { default as providerReducer } from './provider-state';
+
+// reducer updaters
+import * as _visStateUpdaters from './vis-state-updaters';
+export { _visStateUpdaters as visStateUpdaters };
+import * as _mapStateUpdaters from './map-state-updaters';
+export { _mapStateUpdaters as mapStateUpdaters };
+import * as _mapStyleUpdaters from './map-style-updaters';
+export { _mapStyleUpdaters as mapStyleUpdaters };
+import * as _uiStateUpdaters from './ui-state-updaters';
+export { _uiStateUpdaters as uiStateUpdaters }; // This will be deprecated
+import * as _combineUpdaters from './combined-updaters';
+export { _combineUpdaters as combineUpdaters };
+import * as _combinedUpdaters from './combined-updaters';
+export { _combinedUpdaters as combinedUpdaters };
+export { addDataToMapUpdater, replaceDataInMapUpdater } from './combined-updaters';
+
+// reducer merges
+import * as _visStateMergers from './vis-state-merger';
+export { _visStateMergers as visStateMergers };
+export * from './vis-state-selectors';
+export * from './vis-state-merger';
+export * from './provider-state-updaters';
+export * from './provider-state';
+export * from './ui-state';
+export * from './map-state';
+export { getInitialInputStyle, loadMapStylesUpdater, INITIAL_MAP_STYLE } from './map-style-updaters';
+export { fitBoundsUpdater, pickViewportPropsFromMapState, INITIAL_MAP_STATE } from './map-state-updaters';
+
+// Helpers
+export * from './composer-helpers';
+
+// export types
+export * from './vis-state-updaters';
+export { INITIAL_UI_STATE } from './ui-state-updaters';
+export { getDefaultMapStyles } from './map-style-updaters';
+export * from './data-utils';
+export * from './export-utils';
+export * from './interaction-utils';
+export * from './layer-utils';
+import * as _providerStateUpdaters from './provider-state-updaters';
+export { _providerStateUpdaters as providerStateUpdaters };
+export { enhanceReduxMiddleware } from './middleware';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/interaction-utils.js

@@ -0,0 +1,96 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { DEFAULT_TOOLTIP_FIELDS, ALL_FIELD_TYPES, TRIP_POINT_FIELDS, TOOLTIP_FORMATS, TOOLTIP_KEY, COMPARE_TYPES } from '@kepler.gl/constants';
+import { parseFieldValue, getFormatter, isNumber, defaultFormatter } from '@kepler.gl/utils';
+import { notNullorUndefined } from '@kepler.gl/common-utils';
+
+/**
+ * Minus sign used in tooltip formatting.
+ * \u2212 or \u002D is the minus sign that d3-format uses for decimal number formatting
+ * d3-format 2.0 uses \u002D
+ */
+export var TOOLTIP_MINUS_SIGN = "\u2212";
+// both are posible negative signs
+export var NEGATIVE_SIGNS = ["-", "\u2212"];
+export var BRUSH_CONFIG = {
+  range: [0, 50]
+};
+export function findFieldsToShow(_ref) {
+  var fields = _ref.fields,
+    id = _ref.id,
+    maxDefaultTooltips = _ref.maxDefaultTooltips;
+  // first find default tooltip fields for trips
+  var fieldsToShow = DEFAULT_TOOLTIP_FIELDS.reduce(function (prev, curr) {
+    if (fields.find(function (_ref2) {
+      var name = _ref2.name;
+      return curr.name === name;
+    })) {
+      // @ts-ignore
+      prev.push(curr);
+    }
+    return prev;
+  }, []);
+  return _defineProperty({}, id, fieldsToShow.length ? fieldsToShow : autoFindTooltipFields(fields, maxDefaultTooltips));
+}
+function autoFindTooltipFields(fields, maxDefaultTooltips) {
+  var ptFields = _mergeFieldPairs(TRIP_POINT_FIELDS);
+  // filter out the default fields that contains lat and lng and any geometry
+  var fieldsToShow = fields.filter(function (_ref4) {
+    var name = _ref4.name,
+      type = _ref4.type;
+    return name.replace(/[_,.]+/g, ' ').trim().split(' ').every(function (seg) {
+      return !ptFields.includes(seg);
+    }) && type !== ALL_FIELD_TYPES.geojson && type !== ALL_FIELD_TYPES.geoarrow && type !== 'object';
+  });
+  return fieldsToShow.slice(0, maxDefaultTooltips).map(function (_ref5) {
+    var name = _ref5.name;
+    return {
+      name: name,
+      format: null
+    };
+  });
+}
+function _mergeFieldPairs(pairs) {
+  return pairs.reduce(function (prev, pair) {
+    return [].concat(_toConsumableArray(prev), _toConsumableArray(pair));
+  }, []);
+}
+export function getTooltipDisplayDeltaValue(_ref6) {
+  var field = _ref6.field,
+    value = _ref6.value,
+    primaryValue = _ref6.primaryValue,
+    compareType = _ref6.compareType;
+  var displayDeltaValue = null;
+  if (
+  // comparison mode only works for numeric field
+  field.type === ALL_FIELD_TYPES.integer || field.type === ALL_FIELD_TYPES.real) {
+    if (isNumber(primaryValue) && isNumber(value)) {
+      var deltaValue = compareType === COMPARE_TYPES.RELATIVE ? value / primaryValue - 1 : value - primaryValue;
+      var deltaFormat = compareType === COMPARE_TYPES.RELATIVE ? TOOLTIP_FORMATS.DECIMAL_PERCENT_FULL_2[TOOLTIP_KEY] : field.displayFormat || TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_3[TOOLTIP_KEY];
+      displayDeltaValue = getFormatter(deltaFormat, field)(deltaValue);
+
+      // safely cast string
+      displayDeltaValue = defaultFormatter(displayDeltaValue);
+      var deltaFirstChar = displayDeltaValue.charAt(0);
+      if (deltaFirstChar !== '+' && !NEGATIVE_SIGNS.includes(deltaFirstChar)) {
+        displayDeltaValue = "+".concat(displayDeltaValue);
+      }
+    } else {
+      displayDeltaValue = TOOLTIP_MINUS_SIGN;
+    }
+  }
+  return displayDeltaValue;
+}
+export function getTooltipDisplayValue(_ref7) {
+  var item = _ref7.item,
+    field = _ref7.field,
+    value = _ref7.value;
+  if (!notNullorUndefined(value)) {
+    return '';
+  }
+  return item !== null && item !== void 0 && item.format ? getFormatter(item === null || item === void 0 ? void 0 : item.format, field)(value) : field.displayFormat ? getFormatter(field.displayFormat, field)(value) : parseFieldValue(value, field.type);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DEFAULT_TOOLTIP_FIELDS","ALL_FIELD_TYPES","TRIP_POINT_FIELDS","TOOLTIP_FORMATS","TOOLTIP_KEY","COMPARE_TYPES","parseFieldValue","getFormatter","isNumber","defaultFormatter","notNullorUndefined","TOOLTIP_MINUS_SIGN","NEGATIVE_SIGNS","BRUSH_CONFIG","range","findFieldsToShow","_ref","fields","id","maxDefaultTooltips","fieldsToShow","reduce","prev","curr","find","_ref2","name","push","_defineProperty","length","autoFindTooltipFields","ptFields","_mergeFieldPairs","filter","_ref4","type","replace","trim","split","every","seg","includes","geojson","geoarrow","slice","map","_ref5","format","pairs","pair","concat","_toConsumableArray","getTooltipDisplayDeltaValue","_ref6","field","value","primaryValue","compareType","displayDeltaValue","integer","real","deltaValue","RELATIVE","deltaFormat","DECIMAL_PERCENT_FULL_2","displayFormat","DECIMAL_DECIMAL_FIXED_3","deltaFirstChar","charAt","getTooltipDisplayValue","_ref7","item"],"sources":["../../src/interaction-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {\n  DEFAULT_TOOLTIP_FIELDS,\n  ALL_FIELD_TYPES,\n  TRIP_POINT_FIELDS,\n  TOOLTIP_FORMATS,\n  TOOLTIP_KEY,\n  COMPARE_TYPES\n} from '@kepler.gl/constants';\n\nimport {Field, TooltipField, CompareType} from '@kepler.gl/types';\nimport {parseFieldValue, getFormatter, isNumber, defaultFormatter} from '@kepler.gl/utils';\nimport {notNullorUndefined} from '@kepler.gl/common-utils';\n\n/**\n * Minus sign used in tooltip formatting.\n * \\u2212 or \\u002D is the minus sign that d3-format uses for decimal number formatting\n * d3-format 2.0 uses \\u002D\n */\nexport const TOOLTIP_MINUS_SIGN = '\\u2212';\n// both are posible negative signs\nexport const NEGATIVE_SIGNS = ['\\u002D', '\\u2212'];\n\nexport const BRUSH_CONFIG: {\n  range: [number, number];\n} = {\n  range: [0, 50]\n};\n\nexport function findFieldsToShow({\n  fields,\n  id,\n  maxDefaultTooltips\n}: {\n  fields: Field[];\n  id: string;\n  maxDefaultTooltips: number;\n}): {\n  [key: string]: string[];\n} {\n  // first find default tooltip fields for trips\n  const fieldsToShow = DEFAULT_TOOLTIP_FIELDS.reduce((prev, curr) => {\n    if (fields.find(({name}) => curr.name === name)) {\n      // @ts-ignore\n      prev.push(curr);\n    }\n    return prev;\n  }, []);\n\n  return {\n    [id]: fieldsToShow.length ? fieldsToShow : autoFindTooltipFields(fields, maxDefaultTooltips)\n  };\n}\n\nfunction autoFindTooltipFields(fields, maxDefaultTooltips) {\n  const ptFields = _mergeFieldPairs(TRIP_POINT_FIELDS);\n  // filter out the default fields that contains lat and lng and any geometry\n  const fieldsToShow = fields.filter(\n    ({name, type}) =>\n      name\n        .replace(/[_,.]+/g, ' ')\n        .trim()\n        .split(' ')\n        .every(seg => !ptFields.includes(seg)) &&\n      type !== ALL_FIELD_TYPES.geojson &&\n      type !== ALL_FIELD_TYPES.geoarrow &&\n      type !== 'object'\n  );\n\n  return fieldsToShow.slice(0, maxDefaultTooltips).map(({name}) => {\n    return {\n      name,\n      format: null\n    };\n  });\n}\n\nfunction _mergeFieldPairs(pairs) {\n  return pairs.reduce((prev, pair) => [...prev, ...pair], []);\n}\n\nexport function getTooltipDisplayDeltaValue({\n  field,\n  value,\n  primaryValue,\n  compareType\n}: {\n  field: Field;\n  value: any;\n  primaryValue: any;\n  compareType?: CompareType;\n}): string | null {\n  let displayDeltaValue: string | null = null;\n\n  if (\n    // comparison mode only works for numeric field\n    field.type === ALL_FIELD_TYPES.integer ||\n    field.type === ALL_FIELD_TYPES.real\n  ) {\n    if (isNumber(primaryValue) && isNumber(value)) {\n      const deltaValue =\n        compareType === COMPARE_TYPES.RELATIVE ? value / primaryValue - 1 : value - primaryValue;\n      const deltaFormat =\n        compareType === COMPARE_TYPES.RELATIVE\n          ? TOOLTIP_FORMATS.DECIMAL_PERCENT_FULL_2[TOOLTIP_KEY]\n          : field.displayFormat || TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_3[TOOLTIP_KEY];\n\n      displayDeltaValue = getFormatter(deltaFormat, field)(deltaValue);\n\n      // safely cast string\n      displayDeltaValue = defaultFormatter(displayDeltaValue);\n      const deltaFirstChar = displayDeltaValue.charAt(0);\n\n      if (deltaFirstChar !== '+' && !NEGATIVE_SIGNS.includes(deltaFirstChar)) {\n        displayDeltaValue = `+${displayDeltaValue}`;\n      }\n    } else {\n      displayDeltaValue = TOOLTIP_MINUS_SIGN;\n    }\n  }\n\n  return displayDeltaValue;\n}\n\nexport function getTooltipDisplayValue({\n  item,\n  field,\n  value\n}: {\n  item: TooltipField | undefined;\n  field: Field;\n  value: any;\n}): string {\n  if (!notNullorUndefined(value)) {\n    return '';\n  }\n\n  return item?.format\n    ? getFormatter(item?.format, field)(value)\n    : field.displayFormat\n    ? getFormatter(field.displayFormat, field)(value)\n    : parseFieldValue(value, field.type);\n}\n"],"mappings":"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","ignoreList":[]}