@kepler.gl/reducers 3.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,372 @@
+// 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.
+
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  keplerGlReducer: true,
+  keplerGlReducerCore: true,
+  visStateLens: true,
+  mapStateLens: true,
+  uiStateLens: true,
+  mapStyleLens: true,
+  visStateReducer: true,
+  mapStateReducer: true,
+  uiStateReducer: true,
+  mapStyleReducer: true,
+  providerReducer: true,
+  visStateUpdaters: true,
+  INITIAL_MAP_STATE: true,
+  mapStateUpdaters: true,
+  getInitialInputStyle: true,
+  loadMapStylesUpdater: true,
+  INITIAL_MAP_STYLE: true,
+  mapStyleUpdaters: true,
+  INITIAL_UI_STATE: true,
+  uiStateUpdaters: true,
+  addDataToMapUpdater: true,
+  combineUpdaters: true,
+  combinedUpdaters: true,
+  visStateMergers: true,
+  providerStateUpdaters: true,
+  enhanceReduxMiddleware: true
+};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _root["default"];
+  }
+});
+Object.defineProperty(exports, "keplerGlReducer", {
+  enumerable: true,
+  get: function get() {
+    return _root["default"];
+  }
+});
+Object.defineProperty(exports, "keplerGlReducerCore", {
+  enumerable: true,
+  get: function get() {
+    return _core["default"];
+  }
+});
+Object.defineProperty(exports, "visStateLens", {
+  enumerable: true,
+  get: function get() {
+    return _core.visStateLens;
+  }
+});
+Object.defineProperty(exports, "mapStateLens", {
+  enumerable: true,
+  get: function get() {
+    return _core.mapStateLens;
+  }
+});
+Object.defineProperty(exports, "uiStateLens", {
+  enumerable: true,
+  get: function get() {
+    return _core.uiStateLens;
+  }
+});
+Object.defineProperty(exports, "mapStyleLens", {
+  enumerable: true,
+  get: function get() {
+    return _core.mapStyleLens;
+  }
+});
+Object.defineProperty(exports, "visStateReducer", {
+  enumerable: true,
+  get: function get() {
+    return _visState["default"];
+  }
+});
+Object.defineProperty(exports, "mapStateReducer", {
+  enumerable: true,
+  get: function get() {
+    return _mapState["default"];
+  }
+});
+Object.defineProperty(exports, "uiStateReducer", {
+  enumerable: true,
+  get: function get() {
+    return _uiState["default"];
+  }
+});
+Object.defineProperty(exports, "mapStyleReducer", {
+  enumerable: true,
+  get: function get() {
+    return _mapStyle["default"];
+  }
+});
+Object.defineProperty(exports, "providerReducer", {
+  enumerable: true,
+  get: function get() {
+    return _providerState["default"];
+  }
+});
+Object.defineProperty(exports, "INITIAL_MAP_STATE", {
+  enumerable: true,
+  get: function get() {
+    return _mapStateUpdaters.INITIAL_MAP_STATE;
+  }
+});
+Object.defineProperty(exports, "getInitialInputStyle", {
+  enumerable: true,
+  get: function get() {
+    return _mapStyleUpdaters.getInitialInputStyle;
+  }
+});
+Object.defineProperty(exports, "loadMapStylesUpdater", {
+  enumerable: true,
+  get: function get() {
+    return _mapStyleUpdaters.loadMapStylesUpdater;
+  }
+});
+Object.defineProperty(exports, "INITIAL_MAP_STYLE", {
+  enumerable: true,
+  get: function get() {
+    return _mapStyleUpdaters.INITIAL_MAP_STYLE;
+  }
+});
+Object.defineProperty(exports, "INITIAL_UI_STATE", {
+  enumerable: true,
+  get: function get() {
+    return _uiStateUpdaters.INITIAL_UI_STATE;
+  }
+});
+Object.defineProperty(exports, "addDataToMapUpdater", {
+  enumerable: true,
+  get: function get() {
+    return _combineUpdaters.addDataToMapUpdater;
+  }
+});
+Object.defineProperty(exports, "enhanceReduxMiddleware", {
+  enumerable: true,
+  get: function get() {
+    return _middleware.enhanceReduxMiddleware;
+  }
+});
+exports.providerStateUpdaters = exports.visStateMergers = exports.combinedUpdaters = exports.combineUpdaters = exports.uiStateUpdaters = exports.mapStyleUpdaters = exports.mapStateUpdaters = exports.visStateUpdaters = void 0;
+
+var _root = _interopRequireDefault(require("./root"));
+
+var _core = _interopRequireWildcard(require("./core"));
+
+var _visState = _interopRequireDefault(require("./vis-state"));
+
+var _mapState = _interopRequireWildcard(require("./map-state"));
+
+Object.keys(_mapState).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _mapState[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _mapState[key];
+    }
+  });
+});
+
+var _uiState = _interopRequireWildcard(require("./ui-state"));
+
+Object.keys(_uiState).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _uiState[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _uiState[key];
+    }
+  });
+});
+
+var _mapStyle = _interopRequireDefault(require("./map-style"));
+
+var _providerState = _interopRequireWildcard(require("./provider-state"));
+
+Object.keys(_providerState).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _providerState[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _providerState[key];
+    }
+  });
+});
+
+var _visStateUpdaters = _interopRequireWildcard(require("./vis-state-updaters"));
+
+exports.visStateUpdaters = _visStateUpdaters;
+Object.keys(_visStateUpdaters).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _visStateUpdaters[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _visStateUpdaters[key];
+    }
+  });
+});
+
+var _mapStateUpdaters = _interopRequireWildcard(require("./map-state-updaters"));
+
+exports.mapStateUpdaters = _mapStateUpdaters;
+
+var _mapStyleUpdaters = _interopRequireWildcard(require("./map-style-updaters"));
+
+exports.mapStyleUpdaters = _mapStyleUpdaters;
+
+var _uiStateUpdaters = _interopRequireWildcard(require("./ui-state-updaters"));
+
+exports.uiStateUpdaters = _uiStateUpdaters;
+
+var _combineUpdaters = _interopRequireWildcard(require("./combined-updaters"));
+
+var _combinedUpdaters = _combineUpdaters;
+exports.combineUpdaters = _combineUpdaters;
+exports.combinedUpdaters = _combineUpdaters;
+
+var _visStateMergers = _interopRequireWildcard(require("./vis-state-merger"));
+
+exports.visStateMergers = _visStateMergers;
+Object.keys(_visStateMergers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _visStateMergers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _visStateMergers[key];
+    }
+  });
+});
+
+var _visStateSelectors = require("./vis-state-selectors");
+
+Object.keys(_visStateSelectors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _visStateSelectors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _visStateSelectors[key];
+    }
+  });
+});
+
+var _providerStateUpdaters = _interopRequireWildcard(require("./provider-state-updaters"));
+
+exports.providerStateUpdaters = _providerStateUpdaters;
+Object.keys(_providerStateUpdaters).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _providerStateUpdaters[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _providerStateUpdaters[key];
+    }
+  });
+});
+
+var _composerHelpers = require("./composer-helpers");
+
+Object.keys(_composerHelpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _composerHelpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _composerHelpers[key];
+    }
+  });
+});
+
+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 _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 _exportUtils = require("./export-utils");
+
+Object.keys(_exportUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _exportUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _exportUtils[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 _middleware = require("./middleware");
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/interaction-utils.d.ts

@@ -0,0 +1,35 @@
+import { Field, TooltipField, CompareType } from '@kepler.gl/types';
+import { DataRow } from '@kepler.gl/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 declare const TOOLTIP_MINUS_SIGN = "\u2212";
+export declare const NEGATIVE_SIGNS: string[];
+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, value }: {
+    item: TooltipField | undefined;
+    field: Field;
+    value: any;
+}): string;

package/dist/interaction-utils.js

@@ -0,0 +1,149 @@
+// 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.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findFieldsToShow = findFieldsToShow;
+exports.getTooltipDisplayDeltaValue = getTooltipDisplayDeltaValue;
+exports.getTooltipDisplayValue = getTooltipDisplayValue;
+exports.BRUSH_CONFIG = exports.NEGATIVE_SIGNS = exports.TOOLTIP_MINUS_SIGN = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _utils = require("@kepler.gl/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
+ */
+var TOOLTIP_MINUS_SIGN = "\u2212"; // both are posible negative signs
+
+exports.TOOLTIP_MINUS_SIGN = TOOLTIP_MINUS_SIGN;
+var NEGATIVE_SIGNS = ["-", "\u2212"];
+exports.NEGATIVE_SIGNS = NEGATIVE_SIGNS;
+var BRUSH_CONFIG = {
+  range: [0, 50]
+};
+exports.BRUSH_CONFIG = BRUSH_CONFIG;
+
+function findFieldsToShow(_ref) {
+  var fields = _ref.fields,
+      id = _ref.id,
+      maxDefaultTooltips = _ref.maxDefaultTooltips;
+
+  // first find default tooltip fields for trips
+  var fieldsToShow = _constants.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(_constants.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 !== _constants.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 === _constants.ALL_FIELD_TYPES.integer || field.type === _constants.ALL_FIELD_TYPES.real)) {
+    var baseDp = primaryData.valueAt(fieldIdx);
+    var dp = data.valueAt(fieldIdx);
+
+    if ((0, _utils.isNumber)(baseDp) && (0, _utils.isNumber)(dp)) {
+      var deltaValue = compareType === _constants.COMPARE_TYPES.RELATIVE ? dp / baseDp - 1 : dp - baseDp;
+      var deltaFormat = compareType === _constants.COMPARE_TYPES.RELATIVE ? _constants.TOOLTIP_FORMATS.DECIMAL_PERCENT_FULL_2[_constants.TOOLTIP_KEY] : item.format || _constants.TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_3[_constants.TOOLTIP_KEY];
+      displayDeltaValue = (0, _utils.getFormatter)(deltaFormat, field)(deltaValue); // safely cast string
+
+      displayDeltaValue = (0, _utils.defaultFormatter)(displayDeltaValue);
+      var deltaFirstChar = displayDeltaValue.charAt(0);
+
+      if (deltaFirstChar !== '+' && !NEGATIVE_SIGNS.includes(deltaFirstChar)) {
+        displayDeltaValue = "+".concat(displayDeltaValue);
+      }
+    } else {
+      displayDeltaValue = TOOLTIP_MINUS_SIGN;
+    }
+  }
+
+  return displayDeltaValue;
+}
+
+function getTooltipDisplayValue(_ref7) {
+  var item = _ref7.item,
+      field = _ref7.field,
+      value = _ref7.value;
+
+  if (!(0, _utils.notNullorUndefined)(value)) {
+    return '';
+  }
+
+  return item !== null && item !== void 0 && item.format ? (0, _utils.getFormatter)(item.format, field)(value) : (0, _utils.parseFieldValue)(value, field.type);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/interaction-utils.ts"],"names":["TOOLTIP_MINUS_SIGN","NEGATIVE_SIGNS","BRUSH_CONFIG","range","findFieldsToShow","fields","id","maxDefaultTooltips","fieldsToShow","DEFAULT_TOOLTIP_FIELDS","reduce","prev","curr","find","name","push","length","autoFindTooltipFields","ptFields","_mergeFieldPairs","TRIP_POINT_FIELDS","filter","type","replace","trim","split","every","seg","includes","ALL_FIELD_TYPES","geojson","slice","map","format","pairs","pair","getTooltipDisplayDeltaValue","primaryData","field","compareType","data","fieldIdx","item","displayDeltaValue","integer","real","baseDp","valueAt","dp","deltaValue","COMPARE_TYPES","RELATIVE","deltaFormat","TOOLTIP_FORMATS","DECIMAL_PERCENT_FULL_2","TOOLTIP_KEY","DECIMAL_DECIMAL_FIXED_3","deltaFirstChar","charAt","getTooltipDisplayValue","value"],"mappings":"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","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  TOOLTIP_FORMATS,\n  TOOLTIP_KEY,\n  COMPARE_TYPES\n} from '@kepler.gl/constants';\n\nimport {Field, TooltipField, CompareType} from '@kepler.gl/types';\nimport {\n  DataRow,\n  parseFieldValue,\n  getFormatter,\n  isNumber,\n  defaultFormatter,\n  notNullorUndefined\n} from '@kepler.gl/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 !== '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, field)(deltaValue);\n\n      // safely cast string\n      displayDeltaValue = defaultFormatter(displayDeltaValue) as string;\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    : parseFieldValue(value, field.type);\n}\n"]}

package/dist/layer-utils.d.ts

@@ -0,0 +1,66 @@
+import { Field, TooltipField, CompareType, SplitMapLayers, InteractionConfig } from '@kepler.gl/types';
+import { Layer, LayerClassesType } from '@kepler.gl/layers';
+import KeplerTable, { Datasets } from '@kepler.gl/table';
+import { VisState } from '@kepler.gl/schemas';
+import { DataRow } from '@kepler.gl/utils';
+export declare type LayersToRender = {
+    [layerId: string]: boolean;
+};
+export declare type AggregationLayerHoverData = {
+    points: any[];
+    colorValue?: any;
+    elevationValue?: any;
+};
+export declare type LayerHoverProp = {
+    data: DataRow | AggregationLayerHoverData | null;
+    fields: Field[];
+    fieldsToShow: TooltipField[];
+    layer: Layer;
+    primaryData?: DataRow | AggregationLayerHoverData | null;
+    compareType?: CompareType;
+};
+/**
+ * Find default layers from fields
+ */
+export declare function findDefaultLayer(dataset: KeplerTable, layerClasses: LayerClassesType): Layer[];
+/**
+ * calculate layer data based on layer type, col Config,
+ * return updated layer if colorDomain, dataMap has changed
+ */
+export declare function calculateLayerData(layer: Layer, state: {
+    datasets: Datasets;
+}, oldLayerData?: any): {
+    layerData: any;
+    layer: Layer;
+};
+/**
+ * Calculate props passed to LayerHoverInfo
+ * @type {typeof import('./layer-utils').getLayerHoverProp}
+ */
+export declare function getLayerHoverProp({ interactionConfig, hoverInfo, layers, layersToRender, datasets }: {
+    interactionConfig: InteractionConfig;
+    hoverInfo: any;
+    layers: Layer[];
+    layersToRender: LayersToRender;
+    datasets: Datasets;
+}): LayerHoverProp | null;
+export declare function renderDeckGlLayer(props: any, layerCallbacks: {
+    [key: string]: any;
+}, idx: number): any;
+export declare function isLayerRenderable(layer: Layer, layerData: any): boolean;
+export declare function isLayerVisible(layer: any, mapLayers: any): any;
+export declare function prepareLayersForDeck(layers: Layer[], layerData: any[]): {
+    [key: string]: boolean;
+};
+export declare function prepareLayersToRender(layers: Layer[], layerData: VisState['layerData'], mapLayers?: SplitMapLayers | undefined | null): LayersToRender;
+export declare function getCustomDeckLayers(deckGlProps: any): any[];
+export declare type ComputeDeckLayersProps = {
+    mapIndex?: number;
+    mapboxApiAccessToken?: string;
+    mapboxApiUrl?: string;
+    primaryMap?: boolean;
+    layersForDeck?: {
+        [key: string]: boolean;
+    };
+};
+export declare function computeDeckLayers({ visState, mapState, mapStyle }: any, options?: ComputeDeckLayersProps, onSetLayerDomain?: (idx: number, value: any) => void, deckGlProps?: any): Layer[];