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

package/dist/utils/index.js

@@ -0,0 +1,361 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  maybeToDate: true,
+  roundValToStep: true,
+  timeToUnixMilli: true,
+  defaultFormatter: true,
+  FIELD_DISPLAY_FORMAT: true,
+  createNewDataEntry: true,
+  datasetColorMaker: true,
+  findDefaultColorField: true,
+  hexToRgb: true,
+  checkColorOrFallback: true,
+  errorNotification: true,
+  dataURItoBlob: true,
+  downloadFile: true,
+  calculateLayerData: true,
+  prepareLayersToRender: true,
+  prepareLayersForDeck: true,
+  negateAccessor: true,
+  applyFilterFieldName: true,
+  applyFiltersToDatasets: true,
+  validateFilterWithData: true,
+  validateFiltersUpdateDatasets: true,
+  getIntervalBins: true,
+  getNumericStepSize: true,
+  formatNumberByStep: true,
+  resetFilterGpuMode: true,
+  assignGpuChannels: true,
+  updateAllLayerDomainData: true,
+  getHexFields: true,
+  containValidTime: true,
+  KeplerTable: true,
+  findPointFieldPairs: true,
+  copyTableAndUpdate: true,
+  createDataContainer: true,
+  createIndexedDataContainer: true,
+  generateHashId: true
+};
+Object.defineProperty(exports, "FIELD_DISPLAY_FORMAT", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.FIELD_DISPLAY_FORMAT;
+  }
+});
+Object.defineProperty(exports, "KeplerTable", {
+  enumerable: true,
+  get: function get() {
+    return _keplerTable["default"];
+  }
+});
+Object.defineProperty(exports, "applyFilterFieldName", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.applyFilterFieldName;
+  }
+});
+Object.defineProperty(exports, "applyFiltersToDatasets", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.applyFiltersToDatasets;
+  }
+});
+Object.defineProperty(exports, "assignGpuChannels", {
+  enumerable: true,
+  get: function get() {
+    return _gpuFilterUtils.assignGpuChannels;
+  }
+});
+Object.defineProperty(exports, "calculateLayerData", {
+  enumerable: true,
+  get: function get() {
+    return _layerUtils.calculateLayerData;
+  }
+});
+Object.defineProperty(exports, "checkColorOrFallback", {
+  enumerable: true,
+  get: function get() {
+    return _colorUtils.checkColorOrFallback;
+  }
+});
+Object.defineProperty(exports, "containValidTime", {
+  enumerable: true,
+  get: function get() {
+    return _tripUtils.containValidTime;
+  }
+});
+Object.defineProperty(exports, "copyTableAndUpdate", {
+  enumerable: true,
+  get: function get() {
+    return _keplerTable.copyTableAndUpdate;
+  }
+});
+Object.defineProperty(exports, "createDataContainer", {
+  enumerable: true,
+  get: function get() {
+    return _dataContainerUtils.createDataContainer;
+  }
+});
+Object.defineProperty(exports, "createIndexedDataContainer", {
+  enumerable: true,
+  get: function get() {
+    return _dataContainerUtils.createIndexedDataContainer;
+  }
+});
+Object.defineProperty(exports, "createNewDataEntry", {
+  enumerable: true,
+  get: function get() {
+    return _datasetUtils.createNewDataEntry;
+  }
+});
+Object.defineProperty(exports, "dataURItoBlob", {
+  enumerable: true,
+  get: function get() {
+    return _exportUtils.dataURItoBlob;
+  }
+});
+Object.defineProperty(exports, "datasetColorMaker", {
+  enumerable: true,
+  get: function get() {
+    return _datasetUtils.datasetColorMaker;
+  }
+});
+Object.defineProperty(exports, "defaultFormatter", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.defaultFormatter;
+  }
+});
+Object.defineProperty(exports, "downloadFile", {
+  enumerable: true,
+  get: function get() {
+    return _exportUtils.downloadFile;
+  }
+});
+Object.defineProperty(exports, "errorNotification", {
+  enumerable: true,
+  get: function get() {
+    return _notificationsUtils.errorNotification;
+  }
+});
+Object.defineProperty(exports, "findDefaultColorField", {
+  enumerable: true,
+  get: function get() {
+    return _datasetUtils.findDefaultColorField;
+  }
+});
+Object.defineProperty(exports, "findPointFieldPairs", {
+  enumerable: true,
+  get: function get() {
+    return _keplerTable.findPointFieldPairs;
+  }
+});
+Object.defineProperty(exports, "formatNumberByStep", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.formatNumberByStep;
+  }
+});
+Object.defineProperty(exports, "generateHashId", {
+  enumerable: true,
+  get: function get() {
+    return _utils.generateHashId;
+  }
+});
+Object.defineProperty(exports, "getHexFields", {
+  enumerable: true,
+  get: function get() {
+    return _h3Utils.getHexFields;
+  }
+});
+Object.defineProperty(exports, "getIntervalBins", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.getIntervalBins;
+  }
+});
+Object.defineProperty(exports, "getNumericStepSize", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.getNumericStepSize;
+  }
+});
+Object.defineProperty(exports, "hexToRgb", {
+  enumerable: true,
+  get: function get() {
+    return _colorUtils.hexToRgb;
+  }
+});
+Object.defineProperty(exports, "maybeToDate", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.maybeToDate;
+  }
+});
+Object.defineProperty(exports, "negateAccessor", {
+  enumerable: true,
+  get: function get() {
+    return _layerUtils.negateAccessor;
+  }
+});
+Object.defineProperty(exports, "prepareLayersForDeck", {
+  enumerable: true,
+  get: function get() {
+    return _layerUtils.prepareLayersForDeck;
+  }
+});
+Object.defineProperty(exports, "prepareLayersToRender", {
+  enumerable: true,
+  get: function get() {
+    return _layerUtils.prepareLayersToRender;
+  }
+});
+Object.defineProperty(exports, "resetFilterGpuMode", {
+  enumerable: true,
+  get: function get() {
+    return _gpuFilterUtils.resetFilterGpuMode;
+  }
+});
+Object.defineProperty(exports, "roundValToStep", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.roundValToStep;
+  }
+});
+Object.defineProperty(exports, "timeToUnixMilli", {
+  enumerable: true,
+  get: function get() {
+    return _dataUtils.timeToUnixMilli;
+  }
+});
+Object.defineProperty(exports, "updateAllLayerDomainData", {
+  enumerable: true,
+  get: function get() {
+    return _visStateUpdaters.updateAllLayerDomainData;
+  }
+});
+Object.defineProperty(exports, "validateFilterWithData", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.validateFilterWithData;
+  }
+});
+Object.defineProperty(exports, "validateFiltersUpdateDatasets", {
+  enumerable: true,
+  get: function get() {
+    return _filterUtils.validateFiltersUpdateDatasets;
+  }
+});
+var _dataUtils = require("./data-utils");
+Object.keys(_dataUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _dataUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _dataUtils[key];
+    }
+  });
+});
+var _datasetUtils = require("./dataset-utils");
+Object.keys(_datasetUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _datasetUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _datasetUtils[key];
+    }
+  });
+});
+var _colorUtils = require("./color-utils");
+Object.keys(_colorUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _colorUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _colorUtils[key];
+    }
+  });
+});
+var _notificationsUtils = require("./notifications-utils");
+var _exportUtils = require("./export-utils");
+var _layerUtils = require("./layer-utils");
+Object.keys(_layerUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _layerUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _layerUtils[key];
+    }
+  });
+});
+var _filterUtils = require("./filter-utils");
+var _gpuFilterUtils = require("./gpu-filter-utils");
+Object.keys(_gpuFilterUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _gpuFilterUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _gpuFilterUtils[key];
+    }
+  });
+});
+var _visStateUpdaters = require("../reducers/vis-state-updaters");
+var _h3Utils = require("../layers/h3-hexagon-layer/h3-utils");
+var _tripUtils = require("../layers/trip-layer/trip-utils");
+var _keplerTable = _interopRequireWildcard(require("./table-utils/kepler-table"));
+var _dataContainerUtils = require("./table-utils/data-container-utils");
+var _dataScaleUtils = require("./data-scale-utils");
+Object.keys(_dataScaleUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _dataScaleUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _dataScaleUtils[key];
+    }
+  });
+});
+var _interactionUtils = require("./interaction-utils");
+Object.keys(_interactionUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _interactionUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _interactionUtils[key];
+    }
+  });
+});
+var _observeDimensions = require("./observe-dimensions");
+Object.keys(_observeDimensions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _observeDimensions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _observeDimensions[key];
+    }
+  });
+});
+var _utils = require("./utils");
+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; }
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_dataUtils","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_datasetUtils","_colorUtils","_notificationsUtils","_exportUtils","_layerUtils","_filterUtils","_gpuFilterUtils","_visStateUpdaters","_h3Utils","_tripUtils","_keplerTable","_interopRequireWildcard","_dataContainerUtils","_dataScaleUtils","_interactionUtils","_observeDimensions","_utils","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","n","__proto__","a","getOwnPropertyDescriptor","u","i","set"],"sources":["../../src/utils/index.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\n// UTILS\nexport {\n  maybeToDate,\n  roundValToStep,\n  timeToUnixMilli,\n  defaultFormatter,\n  FIELD_DISPLAY_FORMAT\n} from './data-utils';\nexport {createNewDataEntry, datasetColorMaker, findDefaultColorField} from './dataset-utils';\nexport {hexToRgb, checkColorOrFallback} from './color-utils';\nexport {errorNotification} from './notifications-utils';\nexport {dataURItoBlob, downloadFile} from './export-utils';\nexport {\n  calculateLayerData,\n  prepareLayersToRender,\n  prepareLayersForDeck,\n  negateAccessor\n} from './layer-utils';\nexport {\n  applyFilterFieldName,\n  applyFiltersToDatasets,\n  validateFilterWithData,\n  validateFiltersUpdateDatasets,\n  getIntervalBins,\n  getNumericStepSize,\n  formatNumberByStep\n} from 'utils/filter-utils';\nexport {resetFilterGpuMode, assignGpuChannels} from 'utils/gpu-filter-utils';\n\n// REDUCER UTILS\nexport {updateAllLayerDomainData} from '../reducers/vis-state-updaters';\nexport {getHexFields} from '../layers/h3-hexagon-layer/h3-utils';\nexport {containValidTime} from '../layers/trip-layer/trip-utils';\n\nexport {\n  default as KeplerTable,\n  findPointFieldPairs,\n  copyTableAndUpdate\n} from './table-utils/kepler-table';\nexport {createDataContainer, createIndexedDataContainer} from './table-utils/data-container-utils';\n\nexport * from './color-utils';\nexport * from './data-scale-utils';\nexport * from './data-utils';\nexport * from './dataset-utils';\nexport * from './gpu-filter-utils';\nexport * from './interaction-utils';\nexport * from './layer-utils';\nexport * from './observe-dimensions';\n\n// CARTO ADDITIONS\nexport { generateHashId } from './utils';\n"],"mappings":"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","ignoreList":[]}

package/dist/utils/interaction-utils.d.ts

@@ -1,36 +1,36 @@
-import { InteractionConfig, TooltipField, CompareType } from '../reducers/vis-state-updaters';
-import { DataRow } from './table-utils/data-row';
-import { Field } from './table-utils/kepler-table';
-/**
- * Minus sign used in tooltip formatting.
- * \u2212 is the minus sign that d3-format uses for decimal number formatting
- */
-export declare const TOOLTIP_MINUS_SIGN = "\u2212";
-export declare function getDefaultInteraction(): InteractionConfig;
-export declare const BRUSH_CONFIG: {
-    range: [number, number];
-};
-export declare function findFieldsToShow({ fields, id, maxDefaultTooltips }: {
-    fields: Field[];
-    id: string;
-    maxDefaultTooltips: number;
-}): {
-    [key: string]: string[];
-};
-/**
- * @type {typeof import('./interaction-utils').getTooltipDisplayDeltaValue}
- */
-export declare function getTooltipDisplayDeltaValue({ primaryData, field, compareType, data, fieldIdx, item }: {
-    item: TooltipField;
-    field: Field;
-    data: DataRow;
-    fieldIdx: number;
-    primaryData: DataRow;
-    compareType: CompareType;
-}): string | null;
-export declare function getTooltipDisplayValue({ item, field, data, fieldIdx }: {
-    item: TooltipField;
-    field: Field;
-    data: DataRow;
-    fieldIdx: number;
-}): string;
+import { InteractionConfig, TooltipField, CompareType } from '../reducers/vis-state-updaters';
+import { DataRow } from './table-utils/data-row';
+import { Field } from './table-utils/kepler-table';
+/**
+ * Minus sign used in tooltip formatting.
+ * \u2212 is the minus sign that d3-format uses for decimal number formatting
+ */
+export declare const TOOLTIP_MINUS_SIGN = "\u2212";
+export declare function getDefaultInteraction(): InteractionConfig;
+export declare const BRUSH_CONFIG: {
+    range: [number, number];
+};
+export declare function findFieldsToShow({ fields, id, maxDefaultTooltips }: {
+    fields: Field[];
+    id: string;
+    maxDefaultTooltips: number;
+}): {
+    [key: string]: string[];
+};
+/**
+ * @type {typeof import('./interaction-utils').getTooltipDisplayDeltaValue}
+ */
+export declare function getTooltipDisplayDeltaValue({ primaryData, field, compareType, data, fieldIdx, item }: {
+    item: TooltipField;
+    field: Field;
+    data: DataRow;
+    fieldIdx: number;
+    primaryData: DataRow;
+    compareType: CompareType;
+}): string | null;
+export declare function getTooltipDisplayValue({ item, field, data, fieldIdx }: {
+    item: TooltipField;
+    field: Field;
+    data: DataRow;
+    fieldIdx: number;
+}): string;

package/dist/utils/interaction-utils.js

@@ -0,0 +1,170 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TOOLTIP_MINUS_SIGN = exports.BRUSH_CONFIG = void 0;
+exports.findFieldsToShow = findFieldsToShow;
+exports.getDefaultInteraction = getDefaultInteraction;
+exports.getTooltipDisplayDeltaValue = getTooltipDisplayDeltaValue;
+exports.getTooltipDisplayValue = getTooltipDisplayValue;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _defaultSettings = require("../constants/default-settings");
+var _dataUtils = require("./data-utils");
+var _icons = require("../components/common/icons");
+var _tooltip = require("../constants/tooltip");
+// 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.
+
+/**
+ * Minus sign used in tooltip formatting.
+ * \u2212 is the minus sign that d3-format uses for decimal number formatting
+ */
+var TOOLTIP_MINUS_SIGN = exports.TOOLTIP_MINUS_SIGN = "\u2212";
+function getDefaultInteraction() {
+  return {
+    tooltip: {
+      id: 'tooltip',
+      label: 'interactions.tooltip',
+      enabled: true,
+      iconComponent: _icons.Messages,
+      config: {
+        fieldsToShow: {},
+        compareMode: false,
+        compareType: _tooltip.COMPARE_TYPES.ABSOLUTE
+      }
+    },
+    geocoder: {
+      id: 'geocoder',
+      label: 'interactions.geocoder',
+      enabled: false,
+      iconComponent: _icons.Pin,
+      position: null
+    },
+    brush: {
+      id: 'brush',
+      label: 'interactions.brush',
+      enabled: false,
+      iconComponent: _icons.Crosshairs,
+      config: {
+        // size is in km
+        size: 0.5
+      }
+    },
+    coordinate: {
+      id: 'coordinate',
+      label: 'interactions.coordinate',
+      enabled: false,
+      iconComponent: _icons.CursorClick,
+      position: null
+    }
+  };
+}
+var BRUSH_CONFIG = exports.BRUSH_CONFIG = {
+  range: [0, 50]
+};
+function findFieldsToShow(_ref) {
+  var fields = _ref.fields,
+    id = _ref.id,
+    maxDefaultTooltips = _ref.maxDefaultTooltips;
+  // first find default tooltip fields for trips
+  var fieldsToShow = _defaultSettings.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 (0, _defineProperty2["default"])({}, id, fieldsToShow.length ? fieldsToShow : autoFindTooltipFields(fields, maxDefaultTooltips));
+}
+function autoFindTooltipFields(fields, maxDefaultTooltips) {
+  var ptFields = _mergeFieldPairs(_defaultSettings.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 !== _defaultSettings.ALL_FIELD_TYPES.geojson && 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((0, _toConsumableArray2["default"])(prev), (0, _toConsumableArray2["default"])(pair));
+  }, []);
+}
+
+/**
+ * @type {typeof import('./interaction-utils').getTooltipDisplayDeltaValue}
+ */
+function getTooltipDisplayDeltaValue(_ref6) {
+  var primaryData = _ref6.primaryData,
+    field = _ref6.field,
+    compareType = _ref6.compareType,
+    data = _ref6.data,
+    fieldIdx = _ref6.fieldIdx,
+    item = _ref6.item;
+  var displayDeltaValue = null;
+  if (primaryData && (
+  // comparison mode only works for numeric field
+  field.type === _defaultSettings.ALL_FIELD_TYPES.integer || field.type === _defaultSettings.ALL_FIELD_TYPES.real)) {
+    var baseDp = primaryData.valueAt(fieldIdx);
+    var dp = data.valueAt(fieldIdx);
+    if ((0, _dataUtils.isNumber)(baseDp) && (0, _dataUtils.isNumber)(dp)) {
+      var deltaValue = compareType === _tooltip.COMPARE_TYPES.RELATIVE ? dp / baseDp - 1 : dp - baseDp;
+      var deltaFormat = compareType === _tooltip.COMPARE_TYPES.RELATIVE ? _tooltip.TOOLTIP_FORMATS.DECIMAL_PERCENT_FULL_2[_tooltip.TOOLTIP_KEY] : item.format || _tooltip.TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_3[_tooltip.TOOLTIP_KEY];
+      displayDeltaValue = (0, _dataUtils.getFormatter)(deltaFormat)(deltaValue);
+
+      // safely cast string
+      displayDeltaValue = (0, _dataUtils.defaultFormatter)(displayDeltaValue);
+      var deltaFirstChar = displayDeltaValue.charAt(0);
+      if (deltaFirstChar !== '+' && deltaFirstChar !== TOOLTIP_MINUS_SIGN) {
+        displayDeltaValue = "+".concat(displayDeltaValue);
+      }
+    } else {
+      displayDeltaValue = TOOLTIP_MINUS_SIGN;
+    }
+  }
+  return displayDeltaValue;
+}
+function getTooltipDisplayValue(_ref7) {
+  var item = _ref7.item,
+    field = _ref7.field,
+    data = _ref7.data,
+    fieldIdx = _ref7.fieldIdx;
+  var dataValue = data.valueAt(fieldIdx);
+  if (!(0, _dataUtils.notNullorUndefined)(dataValue)) {
+    return '';
+  }
+  return item.format ? (0, _dataUtils.getFormatter)(item.format, field)(dataValue) : (0, _dataUtils.parseFieldValue)(dataValue, field.type);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_defaultSettings","require","_dataUtils","_icons","_tooltip","TOOLTIP_MINUS_SIGN","exports","getDefaultInteraction","tooltip","id","label","enabled","iconComponent","Messages","config","fieldsToShow","compareMode","compareType","COMPARE_TYPES","ABSOLUTE","geocoder","Pin","position","brush","Crosshairs","size","coordinate","CursorClick","BRUSH_CONFIG","range","findFieldsToShow","_ref","fields","maxDefaultTooltips","DEFAULT_TOOLTIP_FIELDS","reduce","prev","curr","find","_ref2","name","push","_defineProperty2","length","autoFindTooltipFields","ptFields","_mergeFieldPairs","TRIP_POINT_FIELDS","filter","_ref4","type","replace","trim","split","every","seg","includes","ALL_FIELD_TYPES","geojson","slice","map","_ref5","format","pairs","pair","concat","_toConsumableArray2","getTooltipDisplayDeltaValue","_ref6","primaryData","field","data","fieldIdx","item","displayDeltaValue","integer","real","baseDp","valueAt","dp","isNumber","deltaValue","RELATIVE","deltaFormat","TOOLTIP_FORMATS","DECIMAL_PERCENT_FULL_2","TOOLTIP_KEY","DECIMAL_DECIMAL_FIXED_3","getFormatter","defaultFormatter","deltaFirstChar","charAt","getTooltipDisplayValue","_ref7","dataValue","notNullorUndefined","parseFieldValue"],"sources":["../../src/utils/interaction-utils.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  DEFAULT_TOOLTIP_FIELDS,\n  ALL_FIELD_TYPES,\n  TRIP_POINT_FIELDS\n} from 'constants/default-settings';\nimport {\n  parseFieldValue,\n  getFormatter,\n  isNumber,\n  defaultFormatter,\n  notNullorUndefined\n} from 'utils/data-utils';\nimport {Messages, Crosshairs, CursorClick, Pin} from 'components/common/icons/index';\nimport {TOOLTIP_FORMATS, TOOLTIP_KEY, COMPARE_TYPES} from 'constants/tooltip';\n\nimport {InteractionConfig, TooltipField, CompareType} from '../reducers/vis-state-updaters';\nimport {DataRow} from './table-utils/data-row';\nimport {Field} from './table-utils/kepler-table';\n\n/**\n * Minus sign used in tooltip formatting.\n * \\u2212 is the minus sign that d3-format uses for decimal number formatting\n */\nexport const TOOLTIP_MINUS_SIGN = '\\u2212';\n\nexport function getDefaultInteraction(): InteractionConfig {\n  return {\n    tooltip: {\n      id: 'tooltip',\n      label: 'interactions.tooltip',\n      enabled: true,\n      iconComponent: Messages,\n      config: {\n        fieldsToShow: {},\n        compareMode: false,\n        compareType: COMPARE_TYPES.ABSOLUTE\n      }\n    },\n    geocoder: {\n      id: 'geocoder',\n      label: 'interactions.geocoder',\n      enabled: false,\n      iconComponent: Pin,\n      position: null\n    },\n    brush: {\n      id: 'brush',\n      label: 'interactions.brush',\n      enabled: false,\n      iconComponent: Crosshairs,\n      config: {\n        // size is in km\n        size: 0.5\n      }\n    },\n    coordinate: {\n      id: 'coordinate',\n      label: 'interactions.coordinate',\n      enabled: false,\n      iconComponent: CursorClick,\n      position: null\n    }\n  };\n}\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 !== '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\n/**\n * @type {typeof import('./interaction-utils').getTooltipDisplayDeltaValue}\n */\nexport function getTooltipDisplayDeltaValue({\n  primaryData,\n  field,\n  compareType,\n  data,\n  fieldIdx,\n  item\n}: {\n  item: TooltipField;\n  field: Field;\n  data: DataRow;\n  fieldIdx: number;\n  primaryData: DataRow;\n  compareType: CompareType;\n}): string | null {\n  let displayDeltaValue: string | null = null;\n\n  if (\n    primaryData &&\n    // comparison mode only works for numeric field\n    (field.type === ALL_FIELD_TYPES.integer || field.type === ALL_FIELD_TYPES.real)\n  ) {\n    const baseDp = primaryData.valueAt(fieldIdx);\n    const dp = data.valueAt(fieldIdx);\n    if (isNumber(baseDp) && isNumber(dp)) {\n      const deltaValue = compareType === COMPARE_TYPES.RELATIVE ? dp / baseDp - 1 : dp - baseDp;\n      const deltaFormat =\n        compareType === COMPARE_TYPES.RELATIVE\n          ? TOOLTIP_FORMATS.DECIMAL_PERCENT_FULL_2[TOOLTIP_KEY]\n          : item.format || TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_3[TOOLTIP_KEY];\n\n      displayDeltaValue = getFormatter(deltaFormat)(deltaValue);\n\n      // safely cast string\n      displayDeltaValue = defaultFormatter(displayDeltaValue);\n      const deltaFirstChar = displayDeltaValue.charAt(0);\n      if (deltaFirstChar !== '+' && deltaFirstChar !== TOOLTIP_MINUS_SIGN) {\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  data,\n  fieldIdx\n}: {\n  item: TooltipField;\n  field: Field;\n  data: DataRow;\n  fieldIdx: number;\n}): string {\n  const dataValue = data.valueAt(fieldIdx);\n  if (!notNullorUndefined(dataValue)) {\n    return '';\n  }\n\n  return item.format\n    ? getFormatter(item.format, field)(dataValue)\n    : parseFieldValue(dataValue, field.type);\n}\n"],"mappings":"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","ignoreList":[]}